@octonote/cli 0.0.0-stage → 0.1.4

package/dist/commands/note.js

@@ -0,0 +1,111 @@
+import { writeFile } from "node:fs/promises";
+import { resolveNotebook } from "../core/context.js";
+import { usage } from "../core/errors.js";
+import { parseFrontMatter, withFrontMatter } from "../core/frontmatter.js";
+import { readContent } from "../core/input.js";
+import { emit } from "../core/output.js";
+import { parseRef } from "../core/refs.js";
+import { describeItem, item, setPublished } from "../core/resources.js";
+import { action } from "../core/run.js";
+const contentOptions = (cmd) => cmd
+    .option("-f, --file <path>", 'markdown file ("-" for stdin)')
+    .option("--stdin", "read markdown from stdin");
+export function registerNote(program) {
+    const note = program
+        .command("note")
+        .description("Notes: create, read and edit them as markdown");
+    contentOptions(note
+        .command("create")
+        .description("Create a note, optionally filled from markdown")
+        .argument("[title]", "title (defaults to the file's front matter / first heading)"))
+        .option("-n, --notebook <notebook>", "put it in a notebook (id or exact name)")
+        .option("--publish", "publish it to the web and print the public URL")
+        .action(action(async (ctx, titleArg, opts) => {
+        const raw = await readContent(opts);
+        const { data, body } = parseFrontMatter(raw ?? "");
+        const title = (titleArg ??
+            data.title ??
+            body.match(/^#\s+(.+)$/m)?.[1] ??
+            "Untitled")
+            .trim()
+            .slice(0, 120);
+        const notebookId = opts.notebook
+            ? (await resolveNotebook(ctx, opts.notebook)).id
+            : undefined;
+        const ws = await ctx.workspaceId();
+        const page = await ctx.api.post(`/workspaces/${ws}/pages`, {
+            title,
+            ...(notebookId ? { notebookId } : {}),
+            ...(body.trim() ? { markdown: body } : {}),
+        });
+        const out = item(ctx, "page", page);
+        if (opts.publish)
+            out.publicUrl = (await setPublished(ctx, "page", page.id, true)).publicUrl;
+        emit(out, describeItem);
+    }));
+    note
+        .command("show")
+        .alias("read")
+        .description("Print a note as markdown")
+        .argument("<note>", "note id (pag_…) or URL")
+        .action(action(async (ctx, ref) => {
+        const { id } = parseRef(ref, "page");
+        const md = await ctx.api.get(`/pages/${id}/markdown`);
+        emit({ ...item(ctx, "page", md), markdown: md.markdown }, (d) => d.markdown);
+    }));
+    note
+        .command("pull")
+        .description("Save a note to a markdown file (with front matter, so `note push` knows which note it is)")
+        .argument("<note>", "note id (pag_…) or URL")
+        .option("-o, --out <path>", "file to write (default: <id>.md)")
+        .action(action(async (ctx, ref, opts) => {
+        const { id } = parseRef(ref, "page");
+        const md = await ctx.api.get(`/pages/${id}/markdown`);
+        const path = opts.out ?? `${id}.md`;
+        await writeFile(path, withFrontMatter({ octonote: md.id, title: md.title, updatedAt: md.updatedAt }, md.markdown));
+        emit({ ...item(ctx, "page", md), file: path }, (d) => `Saved ${d.title ? `“${d.title}” ` : ""}to ${d.file}`);
+    }));
+    note
+        .command("push")
+        .description("Replace a note's content with a markdown file (uses the file's front matter id, or --id)")
+        .argument("<file>", 'markdown file ("-" for stdin)')
+        .option("--id <note>", "note to update (overrides the front matter)")
+        .action(action(async (ctx, file, opts) => {
+        const raw = (await readContent({ file })) ?? "";
+        const { data, body } = parseFrontMatter(raw);
+        const ref = opts.id ?? data.octonote;
+        if (!ref)
+            throw usage("Which note? The file has no `octonote:` front matter.", "Pass --id pag_… or `note pull` the note first.");
+        const { id } = parseRef(ref, "page");
+        const page = await ctx.api.put(`/pages/${id}/markdown`, {
+            markdown: body,
+            ...(data.title ? { title: data.title.slice(0, 120) } : {}),
+        });
+        emit(item(ctx, "page", page), (i) => `Updated ${describeItem(i)}`);
+    }));
+    contentOptions(note
+        .command("append")
+        .description("Add markdown to the end of a note")
+        .argument("<note>", "note id (pag_…) or URL"))
+        .option("-t, --text <markdown>", "markdown given inline")
+        .action(action(async (ctx, ref, opts) => {
+        const { id } = parseRef(ref, "page");
+        const markdown = opts.text ?? (await readContent(opts));
+        if (!markdown?.trim())
+            throw usage("Nothing to append.", "Pass --text, --file or --stdin.");
+        const page = await ctx.api.post(`/pages/${id}/markdown/append`, { markdown });
+        emit(item(ctx, "page", page), (i) => `Appended to ${describeItem(i)}`);
+    }));
+    note
+        .command("rename")
+        .description("Rename a note")
+        .argument("<note>", "note id (pag_…)")
+        .argument("<title>", "new title")
+        .action(action(async (ctx, ref, title) => {
+        const { id } = parseRef(ref, "page");
+        const page = await ctx.api.patch(`/pages/${id}`, {
+            title: title.slice(0, 120),
+        });
+        emit(item(ctx, "page", page), (i) => `Renamed ${describeItem(i)}`);
+    }));
+}

package/dist/commands/notebook.js

@@ -0,0 +1,45 @@
+import { resolveNotebook } from "../core/context.js";
+import { emit, table } from "../core/output.js";
+import { describeItem, item } from "../core/resources.js";
+import { action } from "../core/run.js";
+export function registerNotebook(program) {
+    const notebook = program
+        .command("notebook")
+        .description("Notebooks: folders for notes, canvases and projects");
+    notebook
+        .command("list")
+        .description("List notebooks with what's inside")
+        .action(action(async (ctx) => {
+        const ws = await ctx.workspaceId();
+        const rows = await ctx.api.get(`/workspaces/${ws}/notebooks`);
+        emit(rows.map((n) => ({
+            ...item(ctx, "notebook", n),
+            counts: n.counts ?? null,
+        })), (list) => table(list.map((n) => ({
+            id: n.id,
+            name: n.title,
+            contents: n.counts
+                ? `${n.counts.notes} notes · ${n.counts.canvases} canvases · ${n.counts.projects} projects`
+                : "",
+        })), ["id", "name", "contents"]));
+    }));
+    notebook
+        .command("create")
+        .description("Create a notebook")
+        .argument("<name>", "notebook name")
+        .action(action(async (ctx, name) => {
+        const ws = await ctx.workspaceId();
+        const nb = await ctx.api.post(`/workspaces/${ws}/notebooks`, {
+            name: name.slice(0, 120),
+        });
+        emit(item(ctx, "notebook", nb), describeItem);
+    }));
+    notebook
+        .command("show")
+        .description("Show a notebook (id or exact name)")
+        .argument("<notebook>", "notebook id or exact name")
+        .action(action(async (ctx, ref) => {
+        const nb = await resolveNotebook(ctx, ref);
+        emit(item(ctx, "notebook", nb), describeItem);
+    }));
+}

package/dist/commands/project.js

@@ -0,0 +1,101 @@
+import { resolveNotebook } from "../core/context.js";
+import { usage } from "../core/errors.js";
+import { parseFrontMatter } from "../core/frontmatter.js";
+import { readContent } from "../core/input.js";
+import { emit } from "../core/output.js";
+import { appUrl, parseRef } from "../core/refs.js";
+import { describeItem, item, setPublished } from "../core/resources.js";
+import { action } from "../core/run.js";
+const VIEWS = {
+    notes: "notes",
+    note: "notes",
+    canvas: "canvas",
+    split: "split",
+};
+export function registerProject(program) {
+    const project = program
+        .command("project")
+        .description("Projects: one note and one canvas, side by side");
+    project
+        .command("create")
+        .description("Create a project; fill its note from markdown and draw its canvas from mermaid in one go")
+        .argument("<name>", "project name")
+        .option("-d, --description <text>", "one-line description")
+        .option("--note <path>", 'markdown file for the project\'s note ("-" for stdin)')
+        .option("--canvas-mermaid <path>", "mermaid flowchart file to draw on the project's canvas")
+        .option("--view <view>", "what readers see first: notes | canvas | split", "split")
+        .option("-n, --notebook <notebook>", "put it in a notebook (id or exact name)")
+        .option("--publish", "publish it to the web and print the public URL")
+        .action(action(async (ctx, name, opts) => {
+        const view = VIEWS[opts.view];
+        if (!view)
+            throw usage(`Unknown --view "${opts.view}".`, "Use notes, canvas or split.");
+        if (opts.note === "-" && opts.canvasMermaid === "-")
+            throw usage("Only one of --note / --canvas-mermaid can read stdin.");
+        // Read everything first so a bad file doesn't leave a half-made project.
+        const noteMd = opts.note
+            ? parseFrontMatter((await readContent({ file: opts.note })) ?? "")
+                .body
+            : null;
+        const mermaid = opts.canvasMermaid
+            ? await readContent({ file: opts.canvasMermaid })
+            : null;
+        const notebookId = opts.notebook
+            ? (await resolveNotebook(ctx, opts.notebook)).id
+            : undefined;
+        const ws = await ctx.workspaceId();
+        const p = await ctx.api.post(`/workspaces/${ws}/projects`, {
+            name: name.slice(0, 120),
+            ...(opts.description ? { description: opts.description } : {}),
+            ...(notebookId ? { notebookId } : {}),
+        });
+        try {
+            await ctx.api.patch(`/projects/${p.id}`, {
+                settings: { defaultView: view },
+            });
+            if (noteMd?.trim() && p.noteId)
+                await ctx.api.put(`/pages/${p.noteId}/markdown`, {
+                    markdown: noteMd,
+                });
+            if (mermaid?.trim() && p.canvasId)
+                await ctx.api.put(`/canvases/${p.canvasId}/mermaid`, { mermaid });
+        }
+        catch (err) {
+            // The server only checks the note and diagram once the project
+            // exists: remove it again rather than leave it half made.
+            await ctx.api.delete(`/projects/${p.id}`).catch(() => { });
+            throw err;
+        }
+        const out = {
+            ...item(ctx, "project", p),
+            noteId: p.noteId,
+            canvasId: p.canvasId,
+            ...(opts.publish
+                ? {
+                    publicUrl: (await setPublished(ctx, "project", p.id, true))
+                        .publicUrl,
+                }
+                : {}),
+        };
+        emit(out, (d) => `${describeItem(d)}\n  note ${d.noteId} · canvas ${d.canvasId}`);
+    }));
+    project
+        .command("show")
+        .description("Show a project and the ids of its note and canvas")
+        .argument("<project>", "project id (prj_…) or URL")
+        .action(action(async (ctx, ref) => {
+        const { id } = parseRef(ref, "project");
+        const p = await ctx.api.get(`/projects/${id}`);
+        emit({
+            ...item(ctx, "project", p),
+            noteId: p.noteId,
+            canvasId: p.canvasId,
+            noteUrl: p.noteId
+                ? appUrl(ctx.config.webUrl, "page", p.noteId)
+                : null,
+            canvasUrl: p.canvasId
+                ? appUrl(ctx.config.webUrl, "canvas", p.canvasId)
+                : null,
+        }, (d) => `${describeItem(d)}\n  note ${d.noteId} · canvas ${d.canvasId}`);
+    }));
+}

package/dist/core/config.js

@@ -0,0 +1,66 @@
+/**
+ * Where the CLI keeps its sign-in and preferences: ~/.octonote/config.json
+ * (file mode 0600; override the folder with OCTONOTE_CONFIG_DIR). Env vars
+ * win over the file, so agents and CI never need it:
+ *   OCTONOTE_TOKEN      a token from Settings → CLI & agents
+ *   OCTONOTE_API_URL    default https://api.octonote.ai
+ *   OCTONOTE_WEB_URL    default https://octonote.ai
+ *   OCTONOTE_WORKSPACE  workspace id to use
+ */
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// Our own domain, so the CLI never needs updating when hosting moves.
+export const DEFAULT_API_URL = "https://api.octonote.ai";
+export const DEFAULT_WEB_URL = "https://octonote.ai";
+export function configDir() {
+    return process.env.OCTONOTE_CONFIG_DIR || join(homedir(), ".octonote");
+}
+const configPath = () => join(configDir(), "config.json");
+export async function readStored() {
+    try {
+        return JSON.parse(await readFile(configPath(), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+export async function writeStored(patch, replace = false) {
+    const next = replace ? patch : { ...(await readStored()), ...patch };
+    for (const k of Object.keys(next))
+        if (next[k] === undefined)
+            delete next[k];
+    await mkdir(configDir(), { recursive: true, mode: 0o700 });
+    await writeFile(configPath(), `${JSON.stringify(next, null, 2)}\n`, {
+        mode: 0o600,
+    });
+    // writeFile's mode only applies on create; tighten an existing file too.
+    await chmod(configPath(), 0o600).catch(() => undefined);
+}
+/** Only keep an address in the config when it isn't the default, so installs follow the default if hosting moves. */
+export function customUrl(url, fallback) {
+    const clean = url.replace(/\/+$/, "");
+    return clean === fallback ? undefined : clean;
+}
+export async function resolveConfig(flags = {}) {
+    const stored = await readStored();
+    const envToken = process.env.OCTONOTE_TOKEN?.trim();
+    const strip = (u) => u.replace(/\/+$/, "");
+    return {
+        token: envToken || stored.token || null,
+        tokenSource: envToken ? "env" : stored.token ? "file" : null,
+        email: stored.email ?? null,
+        workspaceId: flags.workspace ||
+            process.env.OCTONOTE_WORKSPACE ||
+            stored.workspaceId ||
+            null,
+        apiUrl: strip(flags.apiUrl ||
+            process.env.OCTONOTE_API_URL ||
+            stored.apiUrl ||
+            DEFAULT_API_URL),
+        webUrl: strip(flags.webUrl ||
+            process.env.OCTONOTE_WEB_URL ||
+            stored.webUrl ||
+            DEFAULT_WEB_URL),
+    };
+}

package/dist/core/context.js

@@ -0,0 +1,64 @@
+/**
+ * What every command needs: config, an API client, and the workspace to
+ * work in (flag → OCTONOTE_WORKSPACE → `octonote workspace use` → the
+ * workspace you own).
+ */
+import { CliError, usage } from "./errors.js";
+import { ApiClient } from "./http.js";
+import { resolveConfig } from "./config.js";
+import { VERSION } from "../version.js";
+export async function createContext(flags, { requireAuth = true } = {}) {
+    const config = await resolveConfig(flags);
+    if (requireAuth && !config.token) {
+        throw new CliError("You're not signed in.", "NOT_LOGGED_IN", {
+            hint: "Run `octonote login`, or set OCTONOTE_TOKEN (Settings → CLI & agents → Create token).",
+        });
+    }
+    const api = new ApiClient({
+        apiUrl: config.apiUrl,
+        token: config.token,
+        userAgent: `octonote-cli/${VERSION}`,
+    });
+    let me = null;
+    const getMe = () => (me ??= api.get("/me"));
+    return {
+        config,
+        api,
+        me: getMe,
+        async workspaceId() {
+            const { memberships } = await getMe();
+            if (config.workspaceId) {
+                if (!memberships.some((m) => m.workspace.id === config.workspaceId)) {
+                    throw usage(`You're not a member of workspace ${config.workspaceId}.`, "`octonote workspace list` shows yours.");
+                }
+                return config.workspaceId;
+            }
+            const pick = memberships.find((m) => m.membership.role === "OWNER") ??
+                memberships[0];
+            if (!pick)
+                throw new CliError("This account has no workspace.", "NO_WORKSPACE", {
+                    hint: "Open octonote.ai once to create one.",
+                });
+            return pick.workspace.id;
+        },
+    };
+}
+/** A notebook by id (ntb_…) or by exact name, case-insensitive. */
+export async function resolveNotebook(ctx, ref) {
+    if (/^ntb_/.test(ref)) {
+        const { notebook } = await ctx.api.get(`/notebooks/${ref}`);
+        return notebook;
+    }
+    const ws = await ctx.workspaceId();
+    const all = await ctx.api.get(`/workspaces/${ws}/notebooks`);
+    const wanted = ref.trim().toLowerCase();
+    const matches = all.filter((n) => n.name.trim().toLowerCase() === wanted);
+    if (matches.length === 1)
+        return matches[0];
+    if (matches.length > 1) {
+        throw usage(`More than one notebook is called "${ref}".`, `Use its id: ${matches.map((m) => m.id).join(", ")}`);
+    }
+    throw new CliError(`No notebook called "${ref}".`, "NOT_FOUND", {
+        hint: "`octonote notebook list` shows them; `octonote notebook create` makes one.",
+    });
+}

package/dist/core/errors.js

@@ -0,0 +1,52 @@
+/**
+ * One error type for everything the CLI reports. `code` is stable and
+ * machine-readable (agents branch on it); `hint` says what to do next.
+ * Exit codes: 1 general, 2 usage, 3 auth, 4 not found / no access,
+ * 5 plan limit, 6 network / server.
+ */
+export class CliError extends Error {
+    code;
+    opts;
+    constructor(message, code, opts = {}) {
+        super(message);
+        this.code = code;
+        this.opts = opts;
+        this.name = "CliError";
+    }
+    get hint() {
+        return this.opts.hint;
+    }
+    get exitCode() {
+        if (this.opts.exitCode)
+            return this.opts.exitCode;
+        switch (this.code) {
+            case "USAGE":
+                return 2;
+            case "NOT_LOGGED_IN":
+            case "UNAUTHORIZED":
+                return 3;
+            case "NOT_FOUND":
+            case "FORBIDDEN":
+                return 4;
+            case "PLAN_LIMIT":
+                return 5;
+            case "NETWORK":
+            case "SERVER_ERROR":
+                return 6;
+            default:
+                return 1;
+        }
+    }
+    toJSON() {
+        return {
+            error: {
+                code: this.code,
+                message: this.message,
+                ...(this.hint ? { hint: this.hint } : {}),
+                ...(this.opts.status ? { status: this.opts.status } : {}),
+                ...(this.opts.details ? { details: this.opts.details } : {}),
+            },
+        };
+    }
+}
+export const usage = (message, hint) => new CliError(message, "USAGE", { hint });

package/dist/core/frontmatter.js

@@ -0,0 +1,42 @@
+/**
+ * Minimal YAML front matter for pulled notes, so `note push file.md` knows
+ * which note it is without an id flag:
+ *
+ *   ---
+ *   octonote: pag_…
+ *   title: "My note"
+ *   ---
+ *
+ * Only flat `key: value` pairs; values may be quoted. Anything else in the
+ * file is the note's markdown.
+ */
+const FM_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+export function parseFrontMatter(text) {
+    const m = text.match(FM_RE);
+    if (!m)
+        return { data: {}, body: text };
+    const data = {};
+    for (const line of m[1].split(/\r?\n/)) {
+        const kv = line.match(/^([A-Za-z_][\w-]*):\s*(.*)$/);
+        if (!kv)
+            continue;
+        let value = kv[2].trim();
+        if (/^".*"$/.test(value)) {
+            try {
+                value = JSON.parse(value);
+            }
+            catch {
+                value = value.slice(1, -1);
+            }
+        }
+        else if (/^'.*'$/.test(value))
+            value = value.slice(1, -1).replace(/''/g, "'");
+        data[kv[1]] = value;
+    }
+    // Drop the blank line withFrontMatter puts after the block, so pull → push round-trips exactly.
+    return { data, body: text.slice(m[0].length).replace(/^\r?\n/, "") };
+}
+export function withFrontMatter(data, body) {
+    const lines = Object.entries(data).map(([k, v]) => `${k}: ${JSON.stringify(v)}`);
+    return `---\n${lines.join("\n")}\n---\n\n${body.replace(/^\n+/, "")}`;
+}

package/dist/core/http.js

@@ -0,0 +1,124 @@
+/**
+ * The CLI's only door to Octonote: the public JSON API, with a bearer token.
+ * Unwraps the API's `{ success, result, errorCode, message }` envelope and
+ * turns every failure into a CliError with a stable code. Safe reads retry
+ * on network errors and 502/503/504; writes never retry (no duplicates).
+ */
+import { CliError } from "./errors.js";
+export class ApiClient {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    get(path) {
+        return this.request("GET", path);
+    }
+    post(path, body) {
+        return this.request("POST", path, body);
+    }
+    put(path, body) {
+        return this.request("PUT", path, body);
+    }
+    patch(path, body) {
+        return this.request("PATCH", path, body);
+    }
+    delete(path, body) {
+        return this.request("DELETE", path, body);
+    }
+    async request(method, path, body) {
+        const attempts = method === "GET" ? 3 : 1;
+        let last;
+        for (let i = 0; i < attempts; i++) {
+            try {
+                return await this.once(method, path, body);
+            }
+            catch (err) {
+                last = err;
+                const retryable = err instanceof CliError &&
+                    (err.code === "NETWORK" ||
+                        [502, 503, 504].includes(err.opts.status ?? 0));
+                if (!retryable || i === attempts - 1)
+                    throw err;
+                await new Promise((r) => setTimeout(r, 400 * 2 ** i));
+            }
+        }
+        throw last;
+    }
+    async once(method, path, body) {
+        let res;
+        try {
+            res = await fetch(`${this.opts.apiUrl}${path}`, {
+                method,
+                headers: {
+                    accept: "application/json",
+                    "user-agent": this.opts.userAgent ?? "octonote-cli",
+                    ...(body !== undefined ? { "content-type": "application/json" } : {}),
+                    ...(this.opts.token
+                        ? { authorization: `Bearer ${this.opts.token}` }
+                        : {}),
+                },
+                body: body !== undefined ? JSON.stringify(body) : undefined,
+                signal: AbortSignal.timeout(this.opts.timeoutMs ?? 30_000),
+            });
+        }
+        catch (err) {
+            const timedOut = err instanceof Error && err.name === "TimeoutError";
+            throw new CliError(timedOut
+                ? "Octonote took too long to answer."
+                : `Couldn't reach Octonote at ${this.opts.apiUrl}.`, "NETWORK", { hint: "Check your connection (or OCTONOTE_API_URL) and try again." });
+        }
+        if (res.status === 204)
+            return undefined;
+        const text = await res.text();
+        let json = null;
+        try {
+            json = text ? JSON.parse(text) : null;
+        }
+        catch {
+            // Not JSON (a proxy error page, say): reported below by status.
+        }
+        const envelope = isEnvelope(json) ? json : null;
+        if (res.ok && (!envelope || envelope.success))
+            return (envelope ? envelope.result : json);
+        throw toCliError(res.status, envelope, text);
+    }
+}
+function isEnvelope(v) {
+    return (typeof v === "object" &&
+        v !== null &&
+        "success" in v &&
+        "statusCode" in v &&
+        "message" in v);
+}
+export function toCliError(status, envelope, raw) {
+    const extra = envelope?.extra ?? {};
+    // A specific code from the API (e.g. MERMAID_INVALID, WEB_SESSION_REQUIRED) wins over the generic one.
+    const specific = typeof extra.code === "string" ? extra.code : null;
+    const message = envelope?.message || raw.slice(0, 200) || `Request failed (${status}).`;
+    const code = specific ??
+        (status === 401
+            ? "UNAUTHORIZED"
+            : status === 402
+                ? "PLAN_LIMIT"
+                : status === 403
+                    ? "FORBIDDEN"
+                    : status === 404
+                        ? "NOT_FOUND"
+                        : status >= 500
+                            ? "SERVER_ERROR"
+                            : (envelope?.errorCode ?? "BAD_REQUEST"));
+    const hint = code === "UNAUTHORIZED"
+        ? "Your sign-in expired or was revoked. Run `octonote login` (or set a fresh OCTONOTE_TOKEN)."
+        : code === "PLAN_LIMIT"
+            ? "This workspace reached the Free plan limit. Upgrade at Settings → Plan & billing."
+            : code === "NOT_FOUND"
+                ? "Check the id — it may be deleted, or not shared with you."
+                : code === "WEB_SESSION_REQUIRED"
+                    ? "Do this in the web app, signed in."
+                    : undefined;
+    return new CliError(message, code, {
+        status,
+        hint,
+        details: Object.keys(extra).length ? extra : undefined,
+    });
+}

package/dist/core/input.js

@@ -0,0 +1,28 @@
+/**
+ * Reading content: from a file, or from stdin with "-" / --stdin. Never
+ * prompts — an agent's process must not hang waiting for input.
+ */
+import { readFile } from "node:fs/promises";
+import { usage } from "./errors.js";
+export async function readStdin() {
+    if (process.stdin.isTTY) {
+        throw usage("Nothing on stdin.", "Pipe content in (e.g. `cat note.md | octonote note create --stdin`) or pass --file.");
+    }
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(chunk);
+    return Buffer.concat(chunks).toString("utf8");
+}
+/** `--file path` (or "-" for stdin), `--stdin`, or nothing. */
+export async function readContent(opts) {
+    if (opts.stdin || opts.file === "-")
+        return readStdin();
+    if (!opts.file)
+        return null;
+    try {
+        return await readFile(opts.file, "utf8");
+    }
+    catch {
+        throw usage(`Can't read ${opts.file}.`);
+    }
+}