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 #[arg(long)]
95 flatten: bool,
96 },
97 ExportPptx {
99 package: PathBuf,
100 #[arg(short, long)]
101 output: PathBuf,
102 },
103 ExportDocx {
105 package: PathBuf,
106 #[arg(short, long)]
107 output: PathBuf,
108 },
109 ExportIdml {
111 package: PathBuf,
112 #[arg(short, long)]
113 output: PathBuf,
114 #[arg(long)]
116 idml_only: bool,
117 },
118 Markdown {
120 source: PathBuf,
121 #[arg(short, long)]
122 output: PathBuf,
123 #[arg(long)]
124 template: PathBuf,
125 #[arg(long)]
127 font: Option<PathBuf>,
128 },
129 Schema {
131 #[command(subcommand)]
132 command: SchemaCommands,
133 },
134}
135
136#[derive(Subcommand)]
137enum SchemaCommands {
138 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}