@wafflebase/cli 0.4.0 → 0.4.1

package/dist/bin.js

@@ -2,6 +2,7 @@
 import { createProgram } from './commands/root.js';
 import { registerDocsCommand } from './commands/docs.js';
 import { registerSheetsCommand } from './commands/sheets.js';
+import { registerSlidesCommand } from './commands/slides.js';
 import { registerApiKeysCommand } from './commands/api-keys.js';
 import { registerSchemaCommand } from './commands/schema.js';
 import { registerLoginCommand } from './commands/login.js';
@@ -15,6 +16,7 @@ registerStatusCommand(program);
 registerCtxCommand(program);
 registerDocsCommand(program);
 registerSheetsCommand(program);
+registerSlidesCommand(program);
 registerApiKeysCommand(program);
 registerSchemaCommand(program);
 program.parse();

package/dist/client/http-client.d.ts

@@ -1,4 +1,5 @@
 import type { Document } from '@wafflebase/docs';
+import type { SlidesDocument } from '@wafflebase/slides/node';
 import type { CliConfig } from '../config/config.js';
 export interface ApiResponse<T = unknown> {
     ok: boolean;
@@ -23,12 +24,13 @@ export declare class HttpClient {
     private refreshSession;
     request<T>(method: string, path: string, body?: unknown): Promise<ApiResponse<T>>;
     listDocuments(): Promise<ApiResponse<unknown[]>>;
-    createDocument(title: string, type?: 'doc' | 'sheet'): Promise<ApiResponse<unknown>>;
+    createDocument(title: string, type?: 'doc' | 'sheet' | 'slides'): Promise<ApiResponse<unknown>>;
     getDocument(id: string): Promise<ApiResponse<unknown>>;
     updateDocument(id: string, title: string): Promise<ApiResponse<unknown>>;
     deleteDocument(id: string): Promise<ApiResponse<unknown>>;
     getDocContent(docId: string): Promise<ApiResponse<Document>>;
     putDocContent(docId: string, doc: Document): Promise<ApiResponse<Document>>;
+    putSlidesContent(docId: string, deck: SlidesDocument): Promise<ApiResponse<SlidesDocument>>;
     listTabs(docId: string): Promise<ApiResponse<unknown[]>>;
     getCells(docId: string, tabId: string, range?: string): Promise<ApiResponse<unknown>>;
     getCell(docId: string, tabId: string, sref: string): Promise<ApiResponse<unknown>>;

package/dist/client/http-client.js

@@ -116,6 +116,12 @@ export class HttpClient {
     putDocContent(docId, doc) {
         return this.request('PUT', `/documents/${docId}/content`, doc);
     }
+    // Slides content — same endpoint as docs; the backend dispatches on
+    // the persisted document type, picking the docs writer for `'doc'`
+    // and the slides writer for `'slides'`.
+    putSlidesContent(docId, deck) {
+        return this.request('PUT', `/documents/${docId}/content`, deck);
+    }
     // Tabs
     listTabs(docId) {
         return this.request('GET', `/documents/${docId}/tabs`);

package/dist/commands/slides.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerSlidesCommand(program: Command): void;
+export declare function registerSlidesImportCommand(slides: Command): void;

package/dist/commands/slides.js

@@ -0,0 +1,38 @@
+import { getGlobalOpts, getClient } from './root.js';
+import { outputError } from '../output/formatter.js';
+import { runSlidesImport } from '../slides/import.js';
+export function registerSlidesCommand(program) {
+    const slides = program
+        .command('slides')
+        .alias('slide')
+        .alias('deck')
+        .description('Manage slide decks');
+    registerSlidesImportCommand(slides);
+}
+export function registerSlidesImportCommand(slides) {
+    slides
+        .command('import <file>')
+        .description('Import a .pptx file as a new (or replacement) slides deck')
+        .option('--title <title>', 'Deck title (default: file basename)')
+        .option('--replace <doc-id>', 'Replace content of an existing deck')
+        .option('--yes', 'Skip --replace confirmation prompt', false)
+        .action(async function (file) {
+        const opts = getGlobalOpts(this);
+        const local = this.opts();
+        try {
+            const result = await runSlidesImport({
+                file,
+                title: local.title,
+                replace: local.replace,
+                yes: local.yes,
+                quiet: opts.quiet,
+                dryRun: opts.dryRun,
+            }, getClient(opts));
+            if (result.exitCode !== 0)
+                process.exitCode = result.exitCode;
+        }
+        catch (e) {
+            outputError(e, opts.quiet);
+        }
+    });
+}

package/dist/slides/import.d.ts

@@ -0,0 +1,82 @@
+import type { SlidesDocument, UploadImage } from '@wafflebase/slides/node';
+import { type CliPptxImportOptions } from './pptx-import.js';
+import type { ImportReport } from '@wafflebase/slides/node';
+/**
+ * Parsing surface — split out so tests can inject a stub that returns
+ * a synthetic `SlidesDocument` without building a real `.pptx` byte
+ * buffer. Production callers use the default (`importPptx` from
+ * `./pptx-import.js`).
+ */
+export type SlidesImportParser = (buf: Uint8Array, opts?: CliPptxImportOptions) => Promise<{
+    document: SlidesDocument;
+    report: ImportReport;
+}>;
+/**
+ * Minimal HTTP surface `runSlidesImport` needs from the CLI's
+ * `HttpClient`. Spelled out so tests can pass a stub without depending
+ * on the full client. Mirrors `ImportClient` in `../docs/import.ts`.
+ */
+export interface SlidesImportClient {
+    createDocument: (title: string, type?: 'doc' | 'sheet' | 'slides') => Promise<{
+        ok: boolean;
+        status: number;
+        data: unknown;
+    }>;
+    putSlidesContent: (docId: string, deck: SlidesDocument) => Promise<{
+        ok: boolean;
+        status: number;
+        data: unknown;
+    }>;
+}
+export interface SlidesImportIO {
+    /** Final structured payload — written to stdout as JSON. */
+    stdout: (line: string) => void;
+    stderr: (line: string) => void;
+    /**
+     * Read the pptx bytes for `path`. `'-'` reads from stdin.
+     *
+     * Split out so tests can inject in-memory buffers without juggling
+     * tmp files; the default reads `process.stdin` (or the file
+     * synchronously) at the action site.
+     */
+    readBytes: (path: string) => Promise<Uint8Array>;
+    /**
+     * Prompt the user for a yes/no answer when running interactively.
+     * Returns `true` for affirmative responses (case-insensitive `y` /
+     * `yes`); anything else (including end-of-stream) → `false`.
+     */
+    confirm: (prompt: string) => Promise<boolean>;
+    /** Whether the current process is interactive (a TTY on stdin). */
+    isTTY: boolean;
+}
+export declare const defaultSlidesImportIO: SlidesImportIO;
+export interface RunSlidesImportArgs {
+    /** Source path. `'-'` reads from stdin. */
+    file: string;
+    /** Override the deck title. Falls back to the file basename. */
+    title?: string;
+    /** Existing document ID to overwrite. Pairs with `--yes`. */
+    replace?: string;
+    /** Skip the interactive `--replace` confirmation. */
+    yes?: boolean;
+    /** Override the default base64 image uploader. Tests pass a no-op. */
+    uploadImage?: UploadImage;
+    /** Suppress informational stderr output (errors still reported). */
+    quiet?: boolean;
+    /** Print the request that *would* fire instead of issuing it. */
+    dryRun?: boolean;
+    /** Override the .pptx parser — primarily for tests. */
+    parser?: SlidesImportParser;
+}
+export interface RunSlidesImportResult {
+    /** Process exit code. The action sets `process.exitCode` accordingly. */
+    exitCode: number;
+}
+/**
+ * Pure orchestration for `slides import`. Reads the source `.pptx`,
+ * parses it into a `SlidesDocument`, then either creates a new deck
+ * (default) or overwrites an existing one (`--replace`). Mirrors
+ * `runDocsImport` — see that file for the rationale behind the split
+ * between this function and the Commander action.
+ */
+export declare function runSlidesImport(args: RunSlidesImportArgs, client: SlidesImportClient, io?: SlidesImportIO): Promise<RunSlidesImportResult>;

package/dist/slides/import.js

@@ -0,0 +1,169 @@
+import { readFileSync } from 'node:fs';
+import { basename, extname } from 'node:path';
+import { createInterface } from 'node:readline';
+import { importPptx as defaultImportPptx, InvalidPptxError, } from './pptx-import.js';
+export const defaultSlidesImportIO = {
+    stdout: (line) => {
+        process.stdout.write(line);
+        if (!line.endsWith('\n'))
+            process.stdout.write('\n');
+    },
+    stderr: (line) => {
+        console.error(line);
+    },
+    readBytes: async (path) => {
+        if (path === '-') {
+            return new Promise((resolve, reject) => {
+                const chunks = [];
+                process.stdin.on('data', (c) => chunks.push(c));
+                process.stdin.on('end', () => resolve(new Uint8Array(Buffer.concat(chunks))));
+                process.stdin.on('error', reject);
+            });
+        }
+        return new Uint8Array(readFileSync(path));
+    },
+    confirm: (prompt) => {
+        return new Promise((resolve) => {
+            const rl = createInterface({ input: process.stdin, output: process.stderr });
+            rl.question(prompt, (answer) => {
+                rl.close();
+                const a = answer.trim().toLowerCase();
+                resolve(a === 'y' || a === 'yes');
+            });
+        });
+    },
+    isTTY: process.stdin.isTTY ?? false,
+};
+/**
+ * Pure orchestration for `slides import`. Reads the source `.pptx`,
+ * parses it into a `SlidesDocument`, then either creates a new deck
+ * (default) or overwrites an existing one (`--replace`). Mirrors
+ * `runDocsImport` — see that file for the rationale behind the split
+ * between this function and the Commander action.
+ */
+export async function runSlidesImport(args, client, io = defaultSlidesImportIO) {
+    const { file, replace, yes = false, uploadImage, quiet = false, dryRun = false, parser = defaultImportPptx, } = args;
+    const inferredTitle = args.title ?? defaultTitleFor(file);
+    if (replace) {
+        // `--replace` is destructive: confirm interactively unless `--yes`.
+        if (!yes) {
+            if (!io.isTTY) {
+                io.stderr(JSON.stringify({
+                    error: {
+                        code: 'CONFIRMATION_REQ',
+                        message: `Pass --yes to confirm replacing deck "${replace}".`,
+                    },
+                }, null, 2));
+                return { exitCode: 1 };
+            }
+            const ok = await io.confirm(`This will replace content of ${replace}. Continue? [y/N] `);
+            if (!ok) {
+                if (!quiet)
+                    io.stderr('Aborted.');
+                return { exitCode: 0 };
+            }
+        }
+        const buf = await io.readBytes(file);
+        const parsed = await safeImportPptx(buf, uploadImage, io, parser);
+        if (parsed === null)
+            return { exitCode: 1 };
+        const { document: deck, report } = parsed;
+        if (dryRun) {
+            io.stdout(JSON.stringify({
+                method: 'PUT',
+                path: `/documents/${replace}/content`,
+                body: deck,
+                report: summariseReport(report),
+            }, null, 2));
+            return { exitCode: 0 };
+        }
+        const res = await client.putSlidesContent(replace, deck);
+        if (!res.ok) {
+            io.stderr(JSON.stringify(res.data ?? { error: { code: 'HTTP_ERROR' } }, null, 2));
+            return { exitCode: 1 };
+        }
+        io.stdout(JSON.stringify({ id: replace, replaced: true, report: summariseReport(report) }, null, 2));
+        return { exitCode: 0 };
+    }
+    // Default flow: POST + PUT.
+    const buf = await io.readBytes(file);
+    const parsedNew = await safeImportPptx(buf, uploadImage, io, parser);
+    if (parsedNew === null)
+        return { exitCode: 1 };
+    const { document: deck, report } = parsedNew;
+    // The parser fills `meta.title` with whatever string the .pptx carries
+    // (often "PowerPoint Presentation" or "Imported deck"). The user's
+    // `--title` flag is the source of truth for the deck name — keep the
+    // Yorkie root's title in lock-step with the Document row so the deck
+    // list, editor header, and GET /content all agree.
+    deck.meta.title = inferredTitle;
+    if (dryRun) {
+        io.stdout(JSON.stringify({
+            method: 'POST',
+            path: '/documents',
+            body: { title: inferredTitle, type: 'slides' },
+            followUp: { method: 'PUT', path: '/documents/<new-id>/content' },
+            report: summariseReport(report),
+        }, null, 2));
+        return { exitCode: 0 };
+    }
+    const created = await client.createDocument(inferredTitle, 'slides');
+    if (!created.ok) {
+        io.stderr(JSON.stringify(created.data ?? { error: { code: 'HTTP_ERROR' } }, null, 2));
+        return { exitCode: 1 };
+    }
+    const newId = created.data?.id;
+    if (!newId) {
+        io.stderr(JSON.stringify({ error: { code: 'INVALID_RESPONSE', message: 'Server did not return an id' } }, null, 2));
+        return { exitCode: 1 };
+    }
+    const put = await client.putSlidesContent(newId, deck);
+    if (!put.ok) {
+        io.stderr(JSON.stringify(put.data ?? { error: { code: 'HTTP_ERROR' } }, null, 2));
+        return { exitCode: 1 };
+    }
+    io.stdout(JSON.stringify({ id: newId, title: inferredTitle, report: summariseReport(report) }, null, 2));
+    return { exitCode: 0 };
+}
+function defaultTitleFor(file) {
+    if (file === '-')
+        return 'Untitled';
+    return basename(file, extname(file)) || 'Untitled';
+}
+/**
+ * Collect the parser's `ImportReport` counters into a plain object so
+ * the CLI can print them as JSON. We surface every counter rather than
+ * the `.summary()` string so agentic callers can parse without
+ * regex-matching prose.
+ */
+function summariseReport(report) {
+    return {
+        groupsFlattened: report.groupsFlattened,
+        tablesFlattened: report.tablesFlattened,
+        shadowsDropped: report.shadowsDropped,
+        textBoxesPreScaled: report.textBoxesPreScaled,
+        unknownShapes: report.unknownShapes,
+        unknownLayoutTypes: report.unknownLayoutTypes,
+        tableMergesIgnored: report.tableMergesIgnored,
+        tableBordersApproximated: report.tableBordersApproximated,
+        skippedImages: report.skippedImages,
+    };
+}
+/**
+ * Run `importPptx` and turn `InvalidPptxError` into a structured stderr
+ * body + `null` return so callers can short-circuit with `exitCode: 1`
+ * while keeping the rest of the error envelope (`HTTP_ERROR`,
+ * `INVALID_RESPONSE`, etc.) consistent.
+ */
+async function safeImportPptx(buf, uploadImage, io, parser) {
+    try {
+        return await parser(buf, { uploadImage });
+    }
+    catch (e) {
+        if (e instanceof InvalidPptxError) {
+            io.stderr(JSON.stringify({ error: { code: e.code, message: e.message } }, null, 2));
+            return null;
+        }
+        throw e;
+    }
+}

package/dist/slides/pptx-import.d.ts

@@ -0,0 +1,35 @@
+import '../docs/dom-polyfill.js';
+import { type ImportPptxResult, type UploadImage } from '@wafflebase/slides/node';
+/**
+ * Default `UploadImage` for the CLI: encodes each embedded image as a
+ * `data:` URL. Matches the docs CLI's `inlineBase64Uploader` — the
+ * frontend treats slide image `src` values as opaque strings, so a
+ * self-contained data URL round-trips cleanly through the API and
+ * renders without needing the workspace's `/images` endpoint.
+ *
+ * The trade-off is payload size: a benchmark deck with 25 unique
+ * images and 63 references gains roughly the image-byte total to the
+ * Yorkie document. Acceptable for a v1 CLI import — power users who
+ * want hosted URLs can pass a custom uploader.
+ */
+export declare const inlineBase64SlidesUploader: UploadImage;
+export interface CliPptxImportOptions {
+    /** Override the default base64 uploader — primarily for tests. */
+    uploadImage?: UploadImage;
+}
+/**
+ * Parse a .pptx byte buffer into a `SlidesDocument` via the slides
+ * parser. The DOM polyfill side-effect import installs xmldom's
+ * `DOMParser` globally so the parser's browser-targeted XML reads work
+ * in Node.
+ *
+ * Throws a wrapped `INVALID_PPTX` error when the underlying parser
+ * cannot make sense of the buffer. The CLI command translates that
+ * into the documented `{ error.code: 'INVALID_PPTX' }` exit body
+ * without leaking implementation details.
+ */
+export declare function importPptx(buf: Uint8Array, opts?: CliPptxImportOptions): Promise<ImportPptxResult>;
+export declare class InvalidPptxError extends Error {
+    readonly code = "INVALID_PPTX";
+    constructor(message: string);
+}

package/dist/slides/pptx-import.js

@@ -0,0 +1,49 @@
+import '../docs/dom-polyfill.js';
+import { importPptx as importPptxFromSlides, } from '@wafflebase/slides/node';
+/**
+ * Default `UploadImage` for the CLI: encodes each embedded image as a
+ * `data:` URL. Matches the docs CLI's `inlineBase64Uploader` — the
+ * frontend treats slide image `src` values as opaque strings, so a
+ * self-contained data URL round-trips cleanly through the API and
+ * renders without needing the workspace's `/images` endpoint.
+ *
+ * The trade-off is payload size: a benchmark deck with 25 unique
+ * images and 63 references gains roughly the image-byte total to the
+ * Yorkie document. Acceptable for a v1 CLI import — power users who
+ * want hosted URLs can pass a custom uploader.
+ */
+export const inlineBase64SlidesUploader = async (bytes, mime) => {
+    const base64 = Buffer.from(bytes).toString('base64');
+    const mediaType = mime || 'application/octet-stream';
+    return `data:${mediaType};base64,${base64}`;
+};
+/**
+ * Parse a .pptx byte buffer into a `SlidesDocument` via the slides
+ * parser. The DOM polyfill side-effect import installs xmldom's
+ * `DOMParser` globally so the parser's browser-targeted XML reads work
+ * in Node.
+ *
+ * Throws a wrapped `INVALID_PPTX` error when the underlying parser
+ * cannot make sense of the buffer. The CLI command translates that
+ * into the documented `{ error.code: 'INVALID_PPTX' }` exit body
+ * without leaking implementation details.
+ */
+export async function importPptx(buf, opts = {}) {
+    const arrayBuf = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+    try {
+        return await importPptxFromSlides(arrayBuf, {
+            uploadImage: opts.uploadImage ?? inlineBase64SlidesUploader,
+        });
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        throw new InvalidPptxError(message);
+    }
+}
+export class InvalidPptxError extends Error {
+    code = 'INVALID_PPTX';
+    constructor(message) {
+        super(message);
+        this.name = 'InvalidPptxError';
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wafflebase/cli",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "CLI for Wafflebase spreadsheet API",
   "license": "Apache-2.0",
   "type": "module",
@@ -20,7 +20,8 @@
     "open": "^11.0.0",
     "pdf-lib": "^1.17.1",
     "yaml": "^2.0.0",
-    "@wafflebase/docs": "0.4.0"
+    "@wafflebase/docs": "0.4.1",
+    "@wafflebase/slides": "0.4.1"
   },
   "devDependencies": {
     "@types/fontkit": "^2.0.0",