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 {
38 package: PathBuf,
39 #[arg(short, long)]
40 output: PathBuf,
41 #[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 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 ExportPdf {
85 package: PathBuf,
86 #[arg(short, long)]
87 output: PathBuf,
88 #[arg(long, default_value_t = DEFAULT_EXPORT_SCALE)]
89 scale: f32,
90 #[arg(long)]
92 trust_pack: bool,
93 },
94 ExportPptx {
96 package: PathBuf,
97 #[arg(short, long)]
98 output: PathBuf,
99 },
100 ExportDocx {
102 package: PathBuf,
103 #[arg(short, long)]
104 output: PathBuf,
105 },
106 Markdown {
108 source: PathBuf,
109 #[arg(short, long)]
110 output: PathBuf,
111 #[arg(long, default_value = "report")]
112 template: String,
113 #[arg(long)]
115 font: Option<PathBuf>,
116 },
117 Schema {
119 #[command(subcommand)]
120 command: SchemaCommands,
121 },
122}
123
124#[derive(Subcommand)]
125enum SchemaCommands {
126 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}