@addorimprove/prompt 0.1.0

package/dist/prompt.js

@@ -0,0 +1,556 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/router.ts
+var VALUE_FLAGS = new Set(["q", "name", "parent", "format", "file", "f", "base-url"]);
+function parseArgs(argv) {
+  if (argv.length === 0)
+    return { command: "help", positionals: [], flags: {} };
+  const [command, ...rest] = argv;
+  const positionals = [];
+  const flags = {};
+  for (let i = 0;i < rest.length; i++) {
+    const tok = rest[i];
+    if (tok.startsWith("--")) {
+      const body = tok.slice(2);
+      const eq = body.indexOf("=");
+      if (eq >= 0) {
+        flags[body.slice(0, eq)] = body.slice(eq + 1);
+        continue;
+      }
+      if (VALUE_FLAGS.has(body) && i + 1 < rest.length && !rest[i + 1].startsWith("-")) {
+        flags[body] = rest[++i];
+      } else
+        flags[body] = true;
+    } else if (tok.startsWith("-") && tok.length > 1) {
+      const name = tok.slice(1);
+      if (VALUE_FLAGS.has(name) && i + 1 < rest.length && !rest[i + 1].startsWith("-")) {
+        flags[name] = rest[++i];
+      } else
+        flags[name] = true;
+    } else {
+      positionals.push(tok);
+    }
+  }
+  return { command, positionals, flags };
+}
+function flagStr(flags, ...names) {
+  for (const n of names) {
+    const v = flags[n];
+    if (typeof v === "string")
+      return v;
+  }
+  return;
+}
+
+// src/api.ts
+class ApiError extends Error {
+  status;
+  code;
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "ApiError";
+  }
+}
+
+class ApiClient {
+  cfg;
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  async request(method, path, body) {
+    const f = this.cfg.fetchImpl ?? fetch;
+    const headers = { "x-api-key": this.cfg.apiKey };
+    if (body !== undefined)
+      headers["content-type"] = "application/json";
+    const res = await f(`${this.cfg.baseUrl}/api/v1/me${path}`, {
+      method,
+      headers,
+      body: body === undefined ? undefined : JSON.stringify(body)
+    });
+    if (!res.ok) {
+      let code = "http", message = res.statusText;
+      try {
+        const j = await res.json();
+        if (j?.error) {
+          code = j.error.code ?? code;
+          message = j.error.message ?? message;
+        }
+      } catch {}
+      throw new ApiError(res.status, code, message);
+    }
+    if (res.status === 204)
+      return;
+    return res.json();
+  }
+  getMe() {
+    return this.request("GET", "");
+  }
+  listDocs(q) {
+    const qs = q ? `?q=${encodeURIComponent(q)}` : "";
+    return this.request("GET", `/docs${qs}`);
+  }
+  getDoc(id) {
+    return this.request("GET", `/docs/${id}`);
+  }
+  getVersion(id, label) {
+    return this.request("GET", `/docs/${id}/versions/${encodeURIComponent(label)}`);
+  }
+  getComments(id, label) {
+    return this.request("GET", `/docs/${id}/versions/${encodeURIComponent(label)}/comments`);
+  }
+  createDoc(body) {
+    return this.request("POST", "/docs", body);
+  }
+  addVersion(id, body) {
+    return this.request("POST", `/docs/${id}/versions`, body);
+  }
+  deleteCurrentKey() {
+    return this.request("DELETE", "/keys/current");
+  }
+}
+function describeApiError(e) {
+  switch (e.status) {
+    case 401:
+      return { message: "Not logged in. Run 'prompt login'.", exitCode: 4 };
+    case 404:
+      return { message: "Not found (or not yours).", exitCode: 1 };
+    case 409:
+      return { message: `Label conflict — ${e.message}`, exitCode: 1 };
+    case 400:
+      return { message: e.message, exitCode: 1 };
+    default:
+      return { message: `Request failed (${e.status}): ${e.message}`, exitCode: 1 };
+  }
+}
+
+// src/config.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdirSync, readFileSync, writeFileSync, rmSync, chmodSync, existsSync } from "node:fs";
+var DEFAULT_BASE_URL = "https://app.photosharingapp.com";
+function configDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  return xdg ? join(xdg, "prompt") : join(homedir(), ".config", "prompt");
+}
+function configPath() {
+  return join(configDir(), "config.json");
+}
+function readConfig() {
+  const p = configPath();
+  if (!existsSync(p))
+    return null;
+  try {
+    return JSON.parse(readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeConfig(cfg) {
+  mkdirSync(configDir(), { recursive: true });
+  const p = configPath();
+  writeFileSync(p, JSON.stringify(cfg, null, 2), { mode: 384 });
+  chmodSync(p, 384);
+}
+function saveCredential(cfg) {
+  writeConfig({ ...readConfig() ?? {}, ...cfg });
+}
+function clearCredential() {
+  rmSync(configPath(), { force: true });
+}
+function resolveApiKey() {
+  return process.env.MD_PROMPT_API_KEY ?? readConfig()?.apiKey ?? null;
+}
+function resolveBaseUrl(flag) {
+  return flag ?? process.env.MD_PROMPT_BASE_URL ?? readConfig()?.baseUrl ?? DEFAULT_BASE_URL;
+}
+
+// src/render.ts
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, writeFileSync as writeFileSync2, readFileSync as readFileSync2, rmSync as rmSync2 } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join2 } from "node:path";
+import { createInterface } from "node:readline";
+function renderDocList(docs) {
+  if (docs.length === 0)
+    return "No documents.";
+  return docs.map((d) => `${String(d.id).padEnd(6)} ${d.name}${d.openCommentCount ? `  (${d.openCommentCount} open comments)` : ""}`).join(`
+`);
+}
+function renderDocTree(doc) {
+  const latest = doc.latest?.label;
+  const lines = doc.versions.map((v) => {
+    const tags = [
+      v.commentCount ? `${v.commentCount} comments` : "",
+      v.label === latest ? "latest" : ""
+    ].filter(Boolean).join(", ");
+    return `  ${v.label.padEnd(10)} ${tags}`;
+  });
+  return `#${doc.id} ${doc.name}
+${lines.join(`
+`)}`;
+}
+function renderComments(comments) {
+  if (comments.length === 0)
+    return "No comments.";
+  return `${comments.length} comment(s):
+${JSON.stringify(comments, null, 2)}`;
+}
+function openEditor(template, ext = "md") {
+  const editor = process.env.EDITOR || process.env.VISUAL || "vi";
+  const dir = mkdtempSync(join2(tmpdir(), "prompts-edit-"));
+  const file = join2(dir, `draft.${ext}`);
+  writeFileSync2(file, template, "utf8");
+  try {
+    const r = spawnSync(editor, [file], { stdio: "inherit" });
+    if (r.status !== 0)
+      throw new Error("editor exited non-zero");
+    return readFileSync2(file, "utf8");
+  } finally {
+    rmSync2(dir, { recursive: true, force: true });
+  }
+}
+function confirm(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(`${question} [y/N] `, (ans) => {
+      rl.close();
+      resolve(/^y(es)?$/i.test(ans.trim()));
+    });
+  });
+}
+
+// src/auth.ts
+import { createServer } from "node:http";
+import { spawn } from "node:child_process";
+
+// src/pkce.ts
+import { randomBytes, createHash } from "node:crypto";
+function randomToken(bytes = 32) {
+  return randomBytes(bytes).toString("base64url");
+}
+function pkceChallengeS256(verifier) {
+  return createHash("sha256").update(verifier).digest("base64url");
+}
+function generatePkce() {
+  const verifier = randomToken(32);
+  return { verifier, challenge: pkceChallengeS256(verifier), method: "S256" };
+}
+
+// src/auth.ts
+function buildAuthorizeUrl(p) {
+  const u = new URL("/cli/auth", p.baseUrl);
+  u.searchParams.set("state", p.state);
+  u.searchParams.set("code_challenge", p.challenge);
+  u.searchParams.set("code_challenge_method", "S256");
+  u.searchParams.set("redirect_uri", p.redirectUri);
+  return u.toString();
+}
+function parseCallback(reqUrl) {
+  const u = new URL(reqUrl, "http://127.0.0.1");
+  return {
+    code: u.searchParams.get("code") ?? undefined,
+    state: u.searchParams.get("state") ?? undefined,
+    error: u.searchParams.get("error") ?? undefined
+  };
+}
+async function exchangeCodeForKey(p) {
+  const f = p.fetchImpl ?? fetch;
+  const res = await f(`${p.baseUrl}/api/v1/cli/token`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ code: p.code, code_verifier: p.codeVerifier, redirect_uri: p.redirectUri })
+  });
+  if (!res.ok) {
+    let message = res.statusText;
+    try {
+      const j = await res.json();
+      if (j?.error?.message)
+        message = j.error.message;
+    } catch {}
+    throw new Error(`login failed: ${message}`);
+  }
+  const { key } = await res.json();
+  return key;
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  try {
+    spawn(cmd, args, { stdio: "ignore", detached: true }).unref();
+  } catch {}
+}
+var CALLBACK_TIMEOUT_MS = 2 * 60 * 1000;
+async function login(baseUrlFlag) {
+  const baseUrl = resolveBaseUrl(baseUrlFlag);
+  const { verifier, challenge } = generatePkce();
+  const state = randomToken(16);
+  const { code, redirectUri } = await new Promise((resolve, reject) => {
+    let redirectUri2 = "";
+    const timer = setTimeout(() => {
+      server.close();
+      reject(new Error("login timed out (no browser callback within 2 minutes)"));
+    }, CALLBACK_TIMEOUT_MS);
+    timer.unref();
+    const server = createServer((req, res) => {
+      const { code: code2, state: gotState, error } = parseCallback(req.url ?? "");
+      const finish = (status, msg) => {
+        res.writeHead(status, { "content-type": "text/html" });
+        res.end(`<html><body style="font-family:sans-serif"><h2>${msg}</h2><p>You can close this tab and return to the terminal.</p></body></html>`);
+      };
+      const fail = (err, status, msg) => {
+        finish(status, msg);
+        clearTimeout(timer);
+        server.close();
+        reject(err);
+      };
+      if (error)
+        return fail(new Error(`authorization ${error}`), 400, "Authorization was cancelled.");
+      if (gotState !== state)
+        return fail(new Error("state mismatch"), 400, "State mismatch — aborting.");
+      if (!code2)
+        return fail(new Error("missing code"), 400, "Missing authorization code.");
+      finish(200, "Logged in to Prompt CLI.");
+      clearTimeout(timer);
+      server.close();
+      resolve({ code: code2, redirectUri: redirectUri2 });
+    });
+    server.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (addr === null || typeof addr === "string") {
+        clearTimeout(timer);
+        server.close();
+        return reject(new Error("could not bind loopback port"));
+      }
+      redirectUri2 = `http://127.0.0.1:${addr.port}/callback`;
+      const authorizeUrl = buildAuthorizeUrl({ baseUrl, state, challenge, redirectUri: redirectUri2 });
+      console.log("Opening your browser to authorize the Prompt CLI...");
+      console.log(`If it does not open, visit:
+  ${authorizeUrl}
+`);
+      openBrowser(authorizeUrl);
+    });
+  });
+  const key = await exchangeCodeForKey({ baseUrl, code, codeVerifier: verifier, redirectUri });
+  saveCredential({ apiKey: key, baseUrl: baseUrlFlag ?? readConfig()?.baseUrl });
+  const client = new ApiClient({ baseUrl, apiKey: key });
+  const me = await client.getMe();
+  saveCredential({ user: me });
+  console.log(`Logged in as ${me.name} <${me.email}>.`);
+}
+async function whoami(baseUrlFlag) {
+  const apiKey = resolveApiKey();
+  if (!apiKey) {
+    console.error("Not logged in. Run 'prompt login'.");
+    process.exitCode = 4;
+    return;
+  }
+  const client = new ApiClient({ baseUrl: resolveBaseUrl(baseUrlFlag), apiKey });
+  const me = await client.getMe();
+  console.log(`${me.name} <${me.email}>  (id: ${me.id})`);
+}
+async function logout(baseUrlFlag) {
+  const apiKey = resolveApiKey();
+  if (apiKey) {
+    try {
+      const client = new ApiClient({ baseUrl: resolveBaseUrl(baseUrlFlag), apiKey });
+      await client.deleteCurrentKey();
+    } catch {}
+  }
+  clearCredential();
+  console.log("Logged out.");
+}
+
+// src/commands.ts
+function requireClient(flags) {
+  const apiKey = resolveApiKey();
+  if (!apiKey) {
+    console.error("Not logged in. Run 'prompt login'.");
+    process.exitCode = 4;
+    return null;
+  }
+  return new ApiClient({ baseUrl: resolveBaseUrl(flagStr(flags, "base-url")), apiKey });
+}
+function out(json, data, human) {
+  console.log(json ? JSON.stringify(data, null, 2) : human);
+}
+async function readContent(flags, template) {
+  const file = flagStr(flags, "file", "f");
+  if (file)
+    return (await import("node:fs")).readFileSync(file, "utf8");
+  return openEditor(template);
+}
+async function run(args) {
+  const json = flags(args, "json");
+  const baseFlag = flagStr(args.flags, "base-url");
+  switch (args.command) {
+    case "login":
+      return login(baseFlag);
+    case "logout":
+      return logout(baseFlag);
+    case "whoami":
+      return whoami(baseFlag);
+    case "ls": {
+      const client = requireClient(args.flags);
+      if (!client)
+        return;
+      const { docs } = await client.listDocs(flagStr(args.flags, "q"));
+      return out(json, docs, renderDocList(docs));
+    }
+    case "view": {
+      const client = requireClient(args.flags);
+      if (!client)
+        return;
+      const id = Number(args.positionals[0]);
+      if (!Number.isInteger(id)) {
+        console.error("usage: prompt view <id> [label]");
+        process.exitCode = 1;
+        return;
+      }
+      const label = args.positionals[1];
+      if (label) {
+        const v = await client.getVersion(id, label);
+        return out(json, v, v.content);
+      }
+      const doc = await client.getDoc(id);
+      if (flags(args, "tree"))
+        return out(json, doc, renderDocTree(doc));
+      return out(json, doc, `${renderDocTree(doc)}
+
+--- latest (${doc.latest?.label}) ---
+${doc.latest?.content ?? "(no versions)"}`);
+    }
+    case "comments": {
+      const client = requireClient(args.flags);
+      if (!client)
+        return;
+      const id = Number(args.positionals[0]);
+      const label = args.positionals[1];
+      if (!Number.isInteger(id) || !label) {
+        console.error("usage: prompt comments <id> <label>");
+        process.exitCode = 1;
+        return;
+      }
+      const { comments } = await client.getComments(id, label);
+      return out(json, comments, renderComments(comments));
+    }
+    case "new": {
+      const client = requireClient(args.flags);
+      if (!client)
+        return;
+      const name = flagStr(args.flags, "name");
+      if (!name) {
+        console.error("usage: prompt new --name <name> [-f file] [--format mdx|html]");
+        process.exitCode = 1;
+        return;
+      }
+      const format = flagStr(args.flags, "format") ?? "mdx";
+      const content = await readContent(args.flags, `# ${name}
+`);
+      if (!flags(args, "yes") && !flags(args, "y") && !await confirm(`Create document "${name}"?`)) {
+        console.log("Aborted.");
+        return;
+      }
+      const r = await client.createDoc({ name, content, format });
+      return out(json, r, `Created #${r.id} (${r.label}).`);
+    }
+    case "iterate": {
+      const client = requireClient(args.flags);
+      if (!client)
+        return;
+      const id = Number(args.positionals[0]);
+      if (!Number.isInteger(id)) {
+        console.error("usage: prompt iterate <id> [--parent label] [-f file]");
+        process.exitCode = 1;
+        return;
+      }
+      let parent = flagStr(args.flags, "parent");
+      if (!parent) {
+        const doc = await client.getDoc(id);
+        parent = doc.latest?.label;
+      }
+      if (!parent) {
+        console.error("no parent version found; pass --parent <label>");
+        process.exitCode = 1;
+        return;
+      }
+      const format = flagStr(args.flags, "format") ?? "mdx";
+      const content = await readContent(args.flags, "");
+      if (!flags(args, "yes") && !flags(args, "y") && !await confirm(`Add iterate version off ${parent} on #${id}?`)) {
+        console.log("Aborted.");
+        return;
+      }
+      const r = await client.addVersion(id, { intent: "iterate", parentLabel: parent, content, format });
+      return out(json, r, `Added ${r.label}.`);
+    }
+    case "branch": {
+      const client = requireClient(args.flags);
+      if (!client)
+        return;
+      const id = Number(args.positionals[0]);
+      const parent = args.positionals[1];
+      if (!Number.isInteger(id) || !parent) {
+        console.error("usage: prompt branch <id> <parentLabel> [-f file]");
+        process.exitCode = 1;
+        return;
+      }
+      const format = flagStr(args.flags, "format") ?? "mdx";
+      const content = await readContent(args.flags, "");
+      if (!flags(args, "yes") && !flags(args, "y") && !await confirm(`Branch off ${parent} on #${id}?`)) {
+        console.log("Aborted.");
+        return;
+      }
+      const r = await client.addVersion(id, { intent: "branch", parentLabel: parent, content, format });
+      return out(json, r, `Branched → ${r.label}.`);
+    }
+    case "help":
+    default:
+      console.log(HELP);
+  }
+}
+function flags(args, name) {
+  return args.flags[name] === true;
+}
+var HELP = `prompt — terminal client for the markdown-notes app
+
+Usage: prompt <command> [args] [flags]   (or: npx @addorimprove/prompt <command>)
+
+  login                          Authorize via browser (PKCE) and store a key
+  logout                         Revoke the stored key and remove it locally
+  whoami                         Show the logged-in account
+
+  ls [-q <query>] [--json]       List/search your documents
+  view <id> [label] [--tree]     Show a doc's version tree + latest, or a version's content
+  comments <id> <label>          Show a version's comments
+
+  new --name <n> [-f file] [--format mdx|html]   Create a document
+  iterate <id> [--parent label] [-f file]        Add a version on the same line
+  branch <id> <parentLabel> [-f file]            Fork a new line from a version
+
+Global flags: --base-url <url>, --json, -y/--yes
+Env: MD_PROMPT_API_KEY, MD_PROMPT_BASE_URL (shared with the 'prompt' skill)`;
+
+// bin/prompt.ts
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  try {
+    await run(args);
+  } catch (err) {
+    if (err instanceof ApiError) {
+      const { message, exitCode } = describeApiError(err);
+      console.error(message);
+      process.exitCode = exitCode;
+    } else {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exitCode = 1;
+    }
+  }
+}
+main();

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@addorimprove/prompt",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": { "prompt": "dist/prompt.js" },
+  "files": ["dist"],
+  "scripts": {
+    "test": "bun test",
+    "build": "bun build ./bin/prompt.ts --target=node --outfile=dist/prompt.js && chmod +x dist/prompt.js",
+    "dev": "bun run ./bin/prompt.ts"
+  },
+  "engines": { "node": ">=18" },
+  "devDependencies": {
+    "@types/node": "^20",
+    "bun-types": "^1.3.8",
+    "typescript": "^5"
+  }
+}