Skip to main content

k2f_cli/
lib.rs

1mod markdown;
2
3use std::fs;
4use std::path::PathBuf;
5
6use clap::{Parser, Subcommand};
7use k2f_layout::compile_outcome;
8use k2f_package::{
9    bundled_schema_files, generate_secret_key, inspect_package, load_dir, pack_bytes, sign_package,
10    unpack_bytes, utc_unix_seconds, write_dir, SecretKey, WriteDirOpts,
11};
12use k2f_paint::{OpenedDocument, OFFICIAL_PNG_SCALE};
13use k2f_pdf::{export_opened, PdfExportOptions, PdfScale, DEFAULT_EXPORT_SCALE};
14
15use markdown::{collect_md, convert_markdown};
16
17#[derive(Parser)]
18#[command(
19    name = "k2f",
20    author,
21    version,
22    about = "K2F pack / compile / verify / sign / render / hit-test"
23)]
24struct Cli {
25    #[command(subcommand)]
26    command: Commands,
27}
28
29#[derive(Subcommand)]
30enum Commands {
31    Pack {
32        source: PathBuf,
33        #[arg(short, long)]
34        output: PathBuf,
35    },
36    /// Unpack a .K2F package to a source directory.
37    Unpack {
38        package: PathBuf,
39        #[arg(short, long)]
40        output: PathBuf,
41        /// Include document.K2F.lock (product round-trip).
42        #[arg(long)]
43        include_lock: bool,
44    },
45    Compile {
46        package: PathBuf,
47    },
48    Verify {
49        package: PathBuf,
50    },
51    Keygen {
52        #[arg(short, long)]
53        output: PathBuf,
54    },
55    Sign {
56        package: PathBuf,
57        #[arg(long)]
58        key: PathBuf,
59        #[arg(long)]
60        signed_by: Option<String>,
61        #[arg(long)]
62        signed_at: Option<i64>,
63    },
64    Render {
65        package: PathBuf,
66        #[arg(long, default_value_t = 0)]
67        page: usize,
68        #[arg(long, default_value_t = OFFICIAL_PNG_SCALE)]
69        scale: f32,
70        #[arg(short, long)]
71        output: PathBuf,
72    },
73    /// Hit-test lock geometry. x/y are pt, not pixels.
74    HitTest {
75        package: PathBuf,
76        #[arg(long, default_value_t = 0)]
77        page: usize,
78        #[arg(long)]
79        x: f64,
80        #[arg(long)]
81        y: f64,
82    },
83    /// Draw the published lock into a PDF. Not a second layout engine.
84    ExportPdf {
85        package: PathBuf,
86        #[arg(short, long)]
87        output: PathBuf,
88        #[arg(long, default_value_t = DEFAULT_EXPORT_SCALE)]
89        scale: f32,
90        /// Append per-page source captions and a final integrity verification page.
91        #[arg(long)]
92        trust_pack: bool,
93        /// Paint field glyphs into page content and omit AcroForm widgets.
94        #[arg(long)]
95        flatten: bool,
96    },
97    /// Draw the published lock into a PowerPoint .pptx. Not a second layout engine.
98    ExportPptx {
99        package: PathBuf,
100        #[arg(short, long)]
101        output: PathBuf,
102    },
103    /// Draw the published lock into a Word .docx. Not a second layout engine.
104    ExportDocx {
105        package: PathBuf,
106        #[arg(short, long)]
107        output: PathBuf,
108    },
109    /// Draw the published lock into an InDesign package (IDML + Document Fonts).
110    ExportIdml {
111        package: PathBuf,
112        #[arg(short, long)]
113        output: PathBuf,
114        /// Write a lone .idml (no Document Fonts folder). InDesign will missing-font.
115        #[arg(long)]
116        idml_only: bool,
117    },
118    /// Compile Markdown to a .K2F package. `--template` is an author directory.
119    Markdown {
120        source: PathBuf,
121        #[arg(short, long)]
122        output: PathBuf,
123        #[arg(long)]
124        template: PathBuf,
125        /// Optional OTF/TTF embedded instead of the template default face.
126        #[arg(long)]
127        font: Option<PathBuf>,
128    },
129    /// Dump embedded format JSON Schemas (for version reconciliation).
130    Schema {
131        #[command(subcommand)]
132        command: SchemaCommands,
133    },
134}
135
136#[derive(Subcommand)]
137enum SchemaCommands {
138    /// Write the five format schema files to a directory.
139    Dump {
140        #[arg(short, long)]
141        output: PathBuf,
142    },
143}
144
145pub fn run() -> anyhow::Result<()> {
146    run_from(std::env::args())
147}
148
149pub fn run_from<I, T>(args: I) -> anyhow::Result<()>
150where
151    I: IntoIterator<Item = T>,
152    T: Into<std::ffi::OsString> + Clone,
153{
154    dispatch(Cli::parse_from(args).command)
155}
156
157fn dispatch(command: Commands) -> anyhow::Result<()> {
158    match command {
159        Commands::Pack { source, output } => {
160            let pkg = load_dir(&source)?;
161            fs::write(&output, pack_bytes(&pkg)?)?;
162            eprintln!("packed {}", output.display());
163        }
164        Commands::Unpack {
165            package,
166            output,
167            include_lock,
168        } => {
169            let pkg = unpack_bytes(&fs::read(&package)?)?;
170            write_dir(
171                &pkg,
172                &output,
173                WriteDirOpts {
174                    include_lock,
175                    include_schema: false,
176                },
177            )?;
178            eprintln!("unpacked {}", output.display());
179        }
180        Commands::Compile { package } => {
181            let mut pkg = unpack_bytes(&fs::read(&package)?)?;
182            k2f_package::apply_coverage_subset(&mut pkg.fonts)?;
183            let assets: std::collections::HashMap<String, Vec<u8>> =
184                pkg.assets.clone().into_iter().collect();
185            let outcome = compile_outcome(
186                pkg.engine_manifest(),
187                &pkg.theme_json,
188                &pkg.fonts,
189                if assets.is_empty() {
190                    None
191                } else {
192                    Some(&assets)
193                },
194            )
195            .map_err(|e| anyhow::anyhow!(e))?;
196            pkg.set_lock(&outcome.lock)?;
197            fs::write(&package, pack_bytes(&pkg)?)?;
198            eprintln!(
199                "compiled {} pages={}",
200                package.display(),
201                outcome.lock.geometry.pages.len()
202            );
203            for diag in &outcome.diags {
204                eprintln!("{diag}");
205            }
206        }
207        Commands::Verify { package } => {
208            let bytes = fs::read(&package)?;
209            let pkg = unpack_bytes(&bytes)?;
210            let report = inspect_package(&pkg)?;
211            println!("{}", report.status.code());
212            if pkg.lock_json.is_some() {
213                if let Ok(doc) = OpenedDocument::open(&bytes) {
214                    eprintln!("pages={}", doc.page_count());
215                }
216            }
217            if let Some(fp) = &report.fingerprint {
218                eprintln!(
219                    "fingerprint={fp} signed_by={} signed_at={} generated_by={}",
220                    report.signed_by.as_deref().unwrap_or("-"),
221                    report
222                        .signed_at
223                        .map(|t| t.to_string())
224                        .unwrap_or_else(|| "-".into()),
225                    report.generated_by.as_deref().unwrap_or("-")
226                );
227            } else if let Some(agent) = &report.generated_by {
228                eprintln!("generated_by={agent}");
229            }
230            if !report.status.is_ok() {
231                std::process::exit(1);
232            }
233        }
234        Commands::Keygen { output } => {
235            let key = generate_secret_key()?;
236            fs::write(&output, format!("{}\n", key.to_hex()))?;
237            eprintln!("public={}", key.public_hex());
238            eprintln!("fingerprint={}", key.fingerprint());
239        }
240        Commands::Sign {
241            package,
242            key,
243            signed_by,
244            signed_at,
245        } => {
246            let mut pkg = unpack_bytes(&fs::read(&package)?)?;
247            let secret = SecretKey::from_hex(fs::read_to_string(&key)?.trim())?;
248            sign_package(
249                &mut pkg,
250                &secret,
251                signed_by.as_deref(),
252                signed_at.unwrap_or_else(utc_unix_seconds),
253            )?;
254            fs::write(&package, pack_bytes(&pkg)?)?;
255            eprintln!(
256                "signed {} fingerprint={}",
257                package.display(),
258                secret.fingerprint()
259            );
260        }
261        Commands::Render {
262            package,
263            page,
264            scale,
265            output,
266        } => {
267            let doc = OpenedDocument::open(&fs::read(&package)?)?;
268            println!("{}", doc.banner().as_str());
269            if let Some(fp) = doc.fingerprint() {
270                eprintln!(
271                    "fingerprint={fp} signed_by={} generated_by={}",
272                    doc.signed_by().unwrap_or("-"),
273                    doc.generated_by().unwrap_or("-")
274                );
275            }
276            if doc.banner() != k2f_paint::Banner::Signed
277                && doc.banner() != k2f_paint::Banner::Unsigned
278            {
279                eprintln!("{}", doc.status_code());
280            }
281            let n = doc.page_count();
282            eprintln!("rendering page {page} of {n}");
283            let png = doc.render_page(page, scale)?;
284            fs::write(&output, png)?;
285            if !matches!(
286                doc.banner(),
287                k2f_paint::Banner::Signed | k2f_paint::Banner::Unsigned
288            ) {
289                std::process::exit(1);
290            }
291        }
292        Commands::HitTest {
293            package,
294            page,
295            x,
296            y,
297        } => {
298            let doc = OpenedDocument::open(&fs::read(&package)?)?;
299            let milli = |pt: f64| (pt * 1000.0).round() as i64;
300            match doc.hit_test(page, milli(x), milli(y)) {
301                Some(hit) => {
302                    println!("{}", hit.ids.join(" "));
303                    if let Some([a, b]) = hit.char_range {
304                        eprintln!("chars {a}..{b}");
305                    }
306                }
307                None => {
308                    println!("MISS");
309                    std::process::exit(1);
310                }
311            }
312        }
313        Commands::ExportPdf {
314            package,
315            output,
316            scale,
317            trust_pack,
318            flatten,
319        } => {
320            let scale = PdfScale::from_f32(scale).map_err(|e| anyhow::anyhow!(e))?;
321            let doc = OpenedDocument::open(&fs::read(&package)?)?;
322            let mut options = PdfExportOptions::new(scale);
323            if trust_pack {
324                options = options.with_trust_pack();
325            }
326            if flatten {
327                options = options.with_flatten();
328            }
329            let pdf = export_opened(&doc, options)?;
330            fs::write(&output, pdf)?;
331            eprintln!("wrote {}", output.display());
332        }
333        Commands::ExportPptx { package, output } => {
334            let bytes = k2f_pptx::export_bytes(&fs::read(&package)?)?;
335            fs::write(&output, bytes)?;
336            eprintln!("wrote {}", output.display());
337        }
338        Commands::ExportDocx { package, output } => {
339            let bytes = k2f_docx::export_bytes(&fs::read(&package)?)?;
340            fs::write(&output, bytes)?;
341            eprintln!("wrote {}", output.display());
342        }
343        Commands::ExportIdml {
344            package,
345            output,
346            idml_only,
347        } => {
348            let pkg = k2f_idml::export_handoff_bytes(&fs::read(&package)?)?;
349            let written = k2f_idml::write_handoff_output(&pkg, &output, idml_only)?;
350            eprintln!("wrote {}", written.display());
351        }
352        Commands::Markdown {
353            source,
354            output,
355            template,
356            font,
357        } => {
358            let font_bytes = match font {
359                Some(path) => Some(fs::read(&path)?),
360                None => None,
361            };
362            if source.is_dir() {
363                let mut files = Vec::new();
364                collect_md(&source, &mut files)?;
365                files.sort();
366                if files.is_empty() {
367                    anyhow::bail!("no .md files under {}", source.display());
368                }
369                for md_path in files {
370                    let rel = md_path.strip_prefix(&source).unwrap_or(&md_path);
371                    let dest = output.join(rel).with_extension("K2F");
372                    convert_markdown(&md_path, &dest, &template, font_bytes.as_deref())?;
373                    eprintln!("wrote {}", dest.display());
374                }
375            } else {
376                convert_markdown(&source, &output, &template, font_bytes.as_deref())?;
377                eprintln!("wrote {}", output.display());
378            }
379        }
380        Commands::Schema { command } => match command {
381            SchemaCommands::Dump { output } => {
382                fs::create_dir_all(&output)?;
383                for (rel, text) in bundled_schema_files() {
384                    let name = rel.rsplit('/').next().unwrap_or(rel);
385                    let path = output.join(name);
386                    fs::write(&path, text)?;
387                    eprintln!("wrote {}", path.display());
388                }
389            }
390        },
391    }
392    Ok(())
393}