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    },
94    /// Draw the published lock into a PowerPoint .pptx. Not a second layout engine.
95    ExportPptx {
96        package: PathBuf,
97        #[arg(short, long)]
98        output: PathBuf,
99    },
100    /// Draw the published lock into a Word .docx. Not a second layout engine.
101    ExportDocx {
102        package: PathBuf,
103        #[arg(short, long)]
104        output: PathBuf,
105    },
106    /// Compile Markdown to a .K2F package (report template by default).
107    Markdown {
108        source: PathBuf,
109        #[arg(short, long)]
110        output: PathBuf,
111        #[arg(long, default_value = "report")]
112        template: String,
113        /// Optional OTF/TTF embedded instead of the template default face.
114        #[arg(long)]
115        font: Option<PathBuf>,
116    },
117    /// Dump embedded format JSON Schemas (for version reconciliation).
118    Schema {
119        #[command(subcommand)]
120        command: SchemaCommands,
121    },
122}
123
124#[derive(Subcommand)]
125enum SchemaCommands {
126    /// Write the five format schema files to a directory.
127    Dump {
128        #[arg(short, long)]
129        output: PathBuf,
130    },
131}
132
133pub fn run() -> anyhow::Result<()> {
134    run_from(std::env::args())
135}
136
137pub fn run_from<I, T>(args: I) -> anyhow::Result<()>
138where
139    I: IntoIterator<Item = T>,
140    T: Into<std::ffi::OsString> + Clone,
141{
142    dispatch(Cli::parse_from(args).command)
143}
144
145fn dispatch(command: Commands) -> anyhow::Result<()> {
146    match command {
147        Commands::Pack { source, output } => {
148            let pkg = load_dir(&source)?;
149            fs::write(&output, pack_bytes(&pkg)?)?;
150            eprintln!("packed {}", output.display());
151        }
152        Commands::Unpack {
153            package,
154            output,
155            include_lock,
156        } => {
157            let pkg = unpack_bytes(&fs::read(&package)?)?;
158            write_dir(
159                &pkg,
160                &output,
161                WriteDirOpts {
162                    include_lock,
163                    include_schema: false,
164                },
165            )?;
166            eprintln!("unpacked {}", output.display());
167        }
168        Commands::Compile { package } => {
169            let mut pkg = unpack_bytes(&fs::read(&package)?)?;
170            k2f_package::apply_coverage_subset(&mut pkg.fonts)?;
171            let assets: std::collections::HashMap<String, Vec<u8>> =
172                pkg.assets.clone().into_iter().collect();
173            let outcome = compile_outcome(
174                pkg.engine_manifest(),
175                &pkg.theme_json,
176                &pkg.fonts,
177                if assets.is_empty() {
178                    None
179                } else {
180                    Some(&assets)
181                },
182            )
183            .map_err(|e| anyhow::anyhow!(e))?;
184            pkg.set_lock(&outcome.lock)?;
185            fs::write(&package, pack_bytes(&pkg)?)?;
186            eprintln!(
187                "compiled {} pages={}",
188                package.display(),
189                outcome.lock.geometry.pages.len()
190            );
191            for diag in &outcome.diags {
192                eprintln!("{diag}");
193            }
194        }
195        Commands::Verify { package } => {
196            let bytes = fs::read(&package)?;
197            let pkg = unpack_bytes(&bytes)?;
198            let report = inspect_package(&pkg)?;
199            println!("{}", report.status.code());
200            if pkg.lock_json.is_some() {
201                if let Ok(doc) = OpenedDocument::open(&bytes) {
202                    eprintln!("pages={}", doc.page_count());
203                }
204            }
205            if let Some(fp) = &report.fingerprint {
206                eprintln!(
207                    "fingerprint={fp} signed_by={} signed_at={} generated_by={}",
208                    report.signed_by.as_deref().unwrap_or("-"),
209                    report
210                        .signed_at
211                        .map(|t| t.to_string())
212                        .unwrap_or_else(|| "-".into()),
213                    report.generated_by.as_deref().unwrap_or("-")
214                );
215            } else if let Some(agent) = &report.generated_by {
216                eprintln!("generated_by={agent}");
217            }
218            if !report.status.is_ok() {
219                std::process::exit(1);
220            }
221        }
222        Commands::Keygen { output } => {
223            let key = generate_secret_key()?;
224            fs::write(&output, format!("{}\n", key.to_hex()))?;
225            eprintln!("public={}", key.public_hex());
226            eprintln!("fingerprint={}", key.fingerprint());
227        }
228        Commands::Sign {
229            package,
230            key,
231            signed_by,
232            signed_at,
233        } => {
234            let mut pkg = unpack_bytes(&fs::read(&package)?)?;
235            let secret = SecretKey::from_hex(fs::read_to_string(&key)?.trim())?;
236            sign_package(
237                &mut pkg,
238                &secret,
239                signed_by.as_deref(),
240                signed_at.unwrap_or_else(utc_unix_seconds),
241            )?;
242            fs::write(&package, pack_bytes(&pkg)?)?;
243            eprintln!(
244                "signed {} fingerprint={}",
245                package.display(),
246                secret.fingerprint()
247            );
248        }
249        Commands::Render {
250            package,
251            page,
252            scale,
253            output,
254        } => {
255            let doc = OpenedDocument::open(&fs::read(&package)?)?;
256            println!("{}", doc.banner().as_str());
257            if let Some(fp) = doc.fingerprint() {
258                eprintln!(
259                    "fingerprint={fp} signed_by={} generated_by={}",
260                    doc.signed_by().unwrap_or("-"),
261                    doc.generated_by().unwrap_or("-")
262                );
263            }
264            if doc.banner() != k2f_paint::Banner::Signed
265                && doc.banner() != k2f_paint::Banner::Unsigned
266            {
267                eprintln!("{}", doc.status_code());
268            }
269            let n = doc.page_count();
270            eprintln!("rendering page {page} of {n}");
271            let png = doc.render_page(page, scale)?;
272            fs::write(&output, png)?;
273            if !matches!(
274                doc.banner(),
275                k2f_paint::Banner::Signed | k2f_paint::Banner::Unsigned
276            ) {
277                std::process::exit(1);
278            }
279        }
280        Commands::HitTest {
281            package,
282            page,
283            x,
284            y,
285        } => {
286            let doc = OpenedDocument::open(&fs::read(&package)?)?;
287            let milli = |pt: f64| (pt * 1000.0).round() as i64;
288            match doc.hit_test(page, milli(x), milli(y)) {
289                Some(hit) => {
290                    println!("{}", hit.ids.join(" "));
291                    if let Some([a, b]) = hit.char_range {
292                        eprintln!("chars {a}..{b}");
293                    }
294                }
295                None => {
296                    println!("MISS");
297                    std::process::exit(1);
298                }
299            }
300        }
301        Commands::ExportPdf {
302            package,
303            output,
304            scale,
305            trust_pack,
306        } => {
307            let scale = PdfScale::from_f32(scale).map_err(|e| anyhow::anyhow!(e))?;
308            let doc = OpenedDocument::open(&fs::read(&package)?)?;
309            let mut options = PdfExportOptions::new(scale);
310            if trust_pack {
311                options = options.with_trust_pack();
312            }
313            let pdf = export_opened(&doc, options)?;
314            fs::write(&output, pdf)?;
315            eprintln!("wrote {}", output.display());
316        }
317        Commands::ExportPptx { package, output } => {
318            let bytes = k2f_pptx::export_bytes(&fs::read(&package)?)?;
319            fs::write(&output, bytes)?;
320            eprintln!("wrote {}", output.display());
321        }
322        Commands::ExportDocx { package, output } => {
323            let bytes = k2f_docx::export_bytes(&fs::read(&package)?)?;
324            fs::write(&output, bytes)?;
325            eprintln!("wrote {}", output.display());
326        }
327        Commands::Markdown {
328            source,
329            output,
330            template,
331            font,
332        } => {
333            let font_bytes = match font {
334                Some(path) => Some(fs::read(&path)?),
335                None => None,
336            };
337            if source.is_dir() {
338                let mut files = Vec::new();
339                collect_md(&source, &mut files)?;
340                files.sort();
341                if files.is_empty() {
342                    anyhow::bail!("no .md files under {}", source.display());
343                }
344                for md_path in files {
345                    let rel = md_path.strip_prefix(&source).unwrap_or(&md_path);
346                    let dest = output.join(rel).with_extension("K2F");
347                    convert_markdown(&md_path, &dest, &template, font_bytes.as_deref())?;
348                    eprintln!("wrote {}", dest.display());
349                }
350            } else {
351                convert_markdown(&source, &output, &template, font_bytes.as_deref())?;
352                eprintln!("wrote {}", output.display());
353            }
354        }
355        Commands::Schema { command } => match command {
356            SchemaCommands::Dump { output } => {
357                fs::create_dir_all(&output)?;
358                for (rel, text) in bundled_schema_files() {
359                    let name = rel.rsplit('/').next().unwrap_or(rel);
360                    let path = output.join(name);
361                    fs::write(&path, text)?;
362                    eprintln!("wrote {}", path.display());
363                }
364            }
365        },
366    }
367    Ok(())
368}