mod markdown;
use std::fs;
use std::path::PathBuf;
use clap::{Parser, Subcommand};
use k2f_layout::compile_outcome;
use k2f_package::{
bundled_schema_files, generate_secret_key, inspect_package, load_dir, pack_bytes, sign_package,
unpack_bytes, utc_unix_seconds, write_dir, SecretKey, WriteDirOpts,
};
use k2f_paint::{OpenedDocument, OFFICIAL_PNG_SCALE};
use k2f_pdf::{export_opened, PdfExportOptions, PdfScale, DEFAULT_EXPORT_SCALE};
use markdown::{collect_md, convert_markdown};
#[derive(Parser)]
#[command(
name = "k2f",
author,
version,
about = "K2F pack / compile / verify / sign / render / hit-test"
)]
struct Cli {
#[command(subcommand)]
command: Commands,
}
#[derive(Subcommand)]
enum Commands {
Pack {
source: PathBuf,
#[arg(short, long)]
output: PathBuf,
},
Unpack {
package: PathBuf,
#[arg(short, long)]
output: PathBuf,
#[arg(long)]
include_lock: bool,
},
Compile {
package: PathBuf,
},
Verify {
package: PathBuf,
},
Keygen {
#[arg(short, long)]
output: PathBuf,
},
Sign {
package: PathBuf,
#[arg(long)]
key: PathBuf,
#[arg(long)]
signed_by: Option<String>,
#[arg(long)]
signed_at: Option<i64>,
},
Render {
package: PathBuf,
#[arg(long, default_value_t = 0)]
page: usize,
#[arg(long, default_value_t = OFFICIAL_PNG_SCALE)]
scale: f32,
#[arg(short, long)]
output: PathBuf,
},
HitTest {
package: PathBuf,
#[arg(long, default_value_t = 0)]
page: usize,
#[arg(long)]
x: f64,
#[arg(long)]
y: f64,
},
ExportPdf {
package: PathBuf,
#[arg(short, long)]
output: PathBuf,
#[arg(long, default_value_t = DEFAULT_EXPORT_SCALE)]
scale: f32,
#[arg(long)]
trust_pack: bool,
#[arg(long)]
flatten: bool,
},
ExportPptx {
package: PathBuf,
#[arg(short, long)]
output: PathBuf,
},
ExportDocx {
package: PathBuf,
#[arg(short, long)]
output: PathBuf,
},
ExportIdml {
package: PathBuf,
#[arg(short, long)]
output: PathBuf,
#[arg(long)]
idml_only: bool,
},
Markdown {
source: PathBuf,
#[arg(short, long)]
output: PathBuf,
#[arg(long)]
template: PathBuf,
#[arg(long)]
font: Option<PathBuf>,
},
Schema {
#[command(subcommand)]
command: SchemaCommands,
},
}
#[derive(Subcommand)]
enum SchemaCommands {
Dump {
#[arg(short, long)]
output: PathBuf,
},
}
pub fn run() -> anyhow::Result<()> {
run_from(std::env::args())
}
pub fn run_from<I, T>(args: I) -> anyhow::Result<()>
where
I: IntoIterator<Item = T>,
T: Into<std::ffi::OsString> + Clone,
{
dispatch(Cli::parse_from(args).command)
}
fn dispatch(command: Commands) -> anyhow::Result<()> {
match command {
Commands::Pack { source, output } => {
let pkg = load_dir(&source)?;
fs::write(&output, pack_bytes(&pkg)?)?;
eprintln!("packed {}", output.display());
}
Commands::Unpack {
package,
output,
include_lock,
} => {
let pkg = unpack_bytes(&fs::read(&package)?)?;
write_dir(
&pkg,
&output,
WriteDirOpts {
include_lock,
include_schema: false,
},
)?;
eprintln!("unpacked {}", output.display());
}
Commands::Compile { package } => {
let mut pkg = unpack_bytes(&fs::read(&package)?)?;
k2f_package::apply_coverage_subset(&mut pkg.fonts)?;
let assets: std::collections::HashMap<String, Vec<u8>> =
pkg.assets.clone().into_iter().collect();
let outcome = compile_outcome(
pkg.engine_manifest(),
&pkg.theme_json,
&pkg.fonts,
if assets.is_empty() {
None
} else {
Some(&assets)
},
)
.map_err(|e| anyhow::anyhow!(e))?;
pkg.set_lock(&outcome.lock)?;
fs::write(&package, pack_bytes(&pkg)?)?;
eprintln!(
"compiled {} pages={}",
package.display(),
outcome.lock.geometry.pages.len()
);
for diag in &outcome.diags {
eprintln!("{diag}");
}
}
Commands::Verify { package } => {
let bytes = fs::read(&package)?;
let pkg = unpack_bytes(&bytes)?;
let report = inspect_package(&pkg)?;
println!("{}", report.status.code());
if pkg.lock_json.is_some() {
if let Ok(doc) = OpenedDocument::open(&bytes) {
eprintln!("pages={}", doc.page_count());
}
}
if let Some(fp) = &report.fingerprint {
eprintln!(
"fingerprint={fp} signed_by={} signed_at={} generated_by={}",
report.signed_by.as_deref().unwrap_or("-"),
report
.signed_at
.map(|t| t.to_string())
.unwrap_or_else(|| "-".into()),
report.generated_by.as_deref().unwrap_or("-")
);
} else if let Some(agent) = &report.generated_by {
eprintln!("generated_by={agent}");
}
if !report.status.is_ok() {
std::process::exit(1);
}
}
Commands::Keygen { output } => {
let key = generate_secret_key()?;
fs::write(&output, format!("{}\n", key.to_hex()))?;
eprintln!("public={}", key.public_hex());
eprintln!("fingerprint={}", key.fingerprint());
}
Commands::Sign {
package,
key,
signed_by,
signed_at,
} => {
let mut pkg = unpack_bytes(&fs::read(&package)?)?;
let secret = SecretKey::from_hex(fs::read_to_string(&key)?.trim())?;
sign_package(
&mut pkg,
&secret,
signed_by.as_deref(),
signed_at.unwrap_or_else(utc_unix_seconds),
)?;
fs::write(&package, pack_bytes(&pkg)?)?;
eprintln!(
"signed {} fingerprint={}",
package.display(),
secret.fingerprint()
);
}
Commands::Render {
package,
page,
scale,
output,
} => {
let doc = OpenedDocument::open(&fs::read(&package)?)?;
println!("{}", doc.banner().as_str());
if let Some(fp) = doc.fingerprint() {
eprintln!(
"fingerprint={fp} signed_by={} generated_by={}",
doc.signed_by().unwrap_or("-"),
doc.generated_by().unwrap_or("-")
);
}
if doc.banner() != k2f_paint::Banner::Signed
&& doc.banner() != k2f_paint::Banner::Unsigned
{
eprintln!("{}", doc.status_code());
}
let n = doc.page_count();
eprintln!("rendering page {page} of {n}");
let png = doc.render_page(page, scale)?;
fs::write(&output, png)?;
if !matches!(
doc.banner(),
k2f_paint::Banner::Signed | k2f_paint::Banner::Unsigned
) {
std::process::exit(1);
}
}
Commands::HitTest {
package,
page,
x,
y,
} => {
let doc = OpenedDocument::open(&fs::read(&package)?)?;
let milli = |pt: f64| (pt * 1000.0).round() as i64;
match doc.hit_test(page, milli(x), milli(y)) {
Some(hit) => {
println!("{}", hit.ids.join(" "));
if let Some([a, b]) = hit.char_range {
eprintln!("chars {a}..{b}");
}
}
None => {
println!("MISS");
std::process::exit(1);
}
}
}
Commands::ExportPdf {
package,
output,
scale,
trust_pack,
flatten,
} => {
let scale = PdfScale::from_f32(scale).map_err(|e| anyhow::anyhow!(e))?;
let doc = OpenedDocument::open(&fs::read(&package)?)?;
let mut options = PdfExportOptions::new(scale);
if trust_pack {
options = options.with_trust_pack();
}
if flatten {
options = options.with_flatten();
}
let pdf = export_opened(&doc, options)?;
fs::write(&output, pdf)?;
eprintln!("wrote {}", output.display());
}
Commands::ExportPptx { package, output } => {
let bytes = k2f_pptx::export_bytes(&fs::read(&package)?)?;
fs::write(&output, bytes)?;
eprintln!("wrote {}", output.display());
}
Commands::ExportDocx { package, output } => {
let bytes = k2f_docx::export_bytes(&fs::read(&package)?)?;
fs::write(&output, bytes)?;
eprintln!("wrote {}", output.display());
}
Commands::ExportIdml {
package,
output,
idml_only,
} => {
let pkg = k2f_idml::export_handoff_bytes(&fs::read(&package)?)?;
let written = k2f_idml::write_handoff_output(&pkg, &output, idml_only)?;
eprintln!("wrote {}", written.display());
}
Commands::Markdown {
source,
output,
template,
font,
} => {
let font_bytes = match font {
Some(path) => Some(fs::read(&path)?),
None => None,
};
if source.is_dir() {
let mut files = Vec::new();
collect_md(&source, &mut files)?;
files.sort();
if files.is_empty() {
anyhow::bail!("no .md files under {}", source.display());
}
for md_path in files {
let rel = md_path.strip_prefix(&source).unwrap_or(&md_path);
let dest = output.join(rel).with_extension("K2F");
convert_markdown(&md_path, &dest, &template, font_bytes.as_deref())?;
eprintln!("wrote {}", dest.display());
}
} else {
convert_markdown(&source, &output, &template, font_bytes.as_deref())?;
eprintln!("wrote {}", output.display());
}
}
Commands::Schema { command } => match command {
SchemaCommands::Dump { output } => {
fs::create_dir_all(&output)?;
for (rel, text) in bundled_schema_files() {
let name = rel.rsplit('/').next().unwrap_or(rel);
let path = output.join(name);
fs::write(&path, text)?;
eprintln!("wrote {}", path.display());
}
}
},
}
Ok(())
}