@grapecool/cli 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,1909 @@
+#!/usr/bin/env node
+
+// src/io.ts
+import fs from "node:fs";
+var detectStdinKind = ({ fd = 0 } = {}) => {
+  if (fd === 0 && process.stdin.isTTY) return "tty";
+  try {
+    const stats = fs.fstatSync(fd);
+    if (stats.isFIFO()) return "pipe";
+    if (stats.isFile()) return "file";
+    return "other";
+  } catch {
+    return "other";
+  }
+};
+var processIo = () => {
+  process.stdout.on("error", (error) => {
+    if (error.code === "EPIPE") process.exit(0);
+  });
+  return {
+    stdout: (text) => {
+      process.stdout.write(text);
+    },
+    stderr: (text) => {
+      process.stderr.write(text);
+    },
+    stdin: process.stdin,
+    stdinKind: detectStdinKind(),
+    stdoutIsTty: Boolean(process.stdout.isTTY)
+  };
+};
+var readStream = async ({
+  stream
+}) => {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+};
+var writeLine = ({ io, text = "" }) => io.stdout(`${text}
+`);
+var writeJson = ({ io, value }) => io.stdout(`${JSON.stringify(value, null, 2)}
+`);
+var writeNotice = ({ io, text }) => io.stderr(`${text}
+`);
+
+// src/open-url.ts
+import { spawn } from "node:child_process";
+var commandFor = ({ url }) => {
+  if (process.platform === "darwin") return { file: "open", args: [url] };
+  if (process.platform === "win32") {
+    return { file: "cmd", args: ["/c", "start", '""', url.replace(/&/g, "^&")] };
+  }
+  return { file: "xdg-open", args: [url] };
+};
+var openUrl = ({ url }) => new Promise((resolve) => {
+  try {
+    const { file, args } = commandFor({ url });
+    const child = spawn(file, args, {
+      stdio: "ignore",
+      detached: true,
+      windowsHide: true
+    });
+    child.once("error", () => resolve(false));
+    child.once("spawn", () => {
+      child.unref();
+      resolve(true);
+    });
+  } catch {
+    resolve(false);
+  }
+});
+
+// src/config.ts
+import os from "node:os";
+import path from "node:path";
+var DEFAULT_GRAPE_URL = "https://grape.cool";
+var DEFAULT_MCP_URL = "https://mcp.grape.cool";
+var trimTrailingSlashes = ({ value }) => value.replace(/\/+$/, "");
+var nonEmpty = ({ value }) => {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+};
+var defaultConfigDir = ({
+  env,
+  platform,
+  homeDir
+}) => {
+  if (platform === "win32") {
+    return path.join(
+      nonEmpty({ value: env.APPDATA }) ?? path.join(homeDir, "AppData", "Roaming"),
+      "grape"
+    );
+  }
+  return path.join(
+    nonEmpty({ value: env.XDG_CONFIG_HOME }) ?? path.join(homeDir, ".config"),
+    "grape"
+  );
+};
+var readConfig = ({
+  env = process.env,
+  platform = process.platform,
+  homeDir = os.homedir()
+} = {}) => ({
+  grapeUrl: trimTrailingSlashes({
+    value: nonEmpty({ value: env.GRAPE_URL }) ?? DEFAULT_GRAPE_URL
+  }),
+  mcpUrl: trimTrailingSlashes({
+    value: nonEmpty({ value: env.GRAPE_MCP_URL }) ?? DEFAULT_MCP_URL
+  }),
+  configDir: nonEmpty({ value: env.GRAPE_CONFIG_DIR }) ?? defaultConfigDir({ env, platform, homeDir }),
+  accessToken: nonEmpty({ value: env.GRAPE_ACCESS_TOKEN })
+});
+
+// src/program.ts
+import { Command, CommanderError } from "commander";
+
+// package.json
+var version = "0.1.0";
+
+// src/version.ts
+var CLI_VERSION = version;
+var USER_AGENT = `grape-cli/${version} (+https://grape.cool/docs#cli)`;
+
+// src/errors.ts
+var EXIT_CODES = {
+  ok: 0,
+  failure: 1,
+  usage: 2,
+  signedOut: 3
+};
+var CliError = class extends Error {
+  code;
+  hint;
+  exitCode;
+  constructor({
+    message,
+    code = "failed",
+    hint = null,
+    exitCode = EXIT_CODES.failure
+  }) {
+    super(message);
+    this.name = "CliError";
+    this.code = code;
+    this.hint = hint;
+    this.exitCode = exitCode;
+  }
+};
+var signedOutError = ({
+  message = "You are not signed in to Grape."
+} = {}) => new CliError({
+  message,
+  code: "signed_out",
+  hint: "Run grape login to sign in.",
+  exitCode: EXIT_CODES.signedOut
+});
+var usageError = ({
+  message,
+  hint = null
+}) => new CliError({ message, hint, code: "usage", exitCode: EXIT_CODES.usage });
+var isCliError = (error) => error instanceof CliError;
+
+// src/commands/site.ts
+import { Option } from "commander";
+
+// src/commands/options.ts
+var parseLimit = ({
+  value,
+  name = "--limit",
+  max
+}) => {
+  if (value === void 0) return null;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > max) {
+    throw usageError({
+      message: `${name} takes a whole number from 1 to ${max}, not "${value}".`
+    });
+  }
+  return parsed;
+};
+var joinWords = ({ words }) => (words ?? []).join(" ").trim();
+
+// src/http.ts
+import axios from "axios";
+var REQUEST_TIMEOUT_MS = 3e4;
+var client = axios.create({
+  timeout: REQUEST_TIMEOUT_MS,
+  maxRedirects: 0,
+  validateStatus: () => true,
+  headers: { "User-Agent": USER_AGENT }
+});
+var flattenHeaders = ({ response }) => Object.fromEntries(
+  Object.entries(response.headers).map(([name, value]) => [
+    name.toLowerCase(),
+    Array.isArray(value) ? value.join(", ") : String(value ?? "")
+  ])
+);
+var unreachableError = ({ url, error }) => {
+  const host = new URL(url).host;
+  const reason = axios.isAxiosError(error) ? error.code === "ECONNABORTED" || error.code === "ETIMEDOUT" ? "the request timed out" : error.code ?? error.message : String(error);
+  return new CliError({
+    code: "network_error",
+    message: `Could not reach ${host}: ${reason}.`,
+    hint: "Check the internet connection and try again."
+  });
+};
+var postRequest = async ({
+  url,
+  data,
+  headers = {},
+  responseType = "json"
+}) => {
+  try {
+    const response = await client.post(url, data, {
+      headers: {
+        Accept: "application/json",
+        ...data instanceof URLSearchParams ? {} : { "Content-Type": "application/json" },
+        ...headers
+      },
+      responseType,
+      // Text stays text: the MCP reply is parsed by its own reader, which
+      // also understands an SSE framed answer.
+      ...responseType === "text" ? { transformResponse: [] } : {}
+    });
+    return {
+      status: response.status,
+      data: response.data,
+      headers: flattenHeaders({ response })
+    };
+  } catch (error) {
+    throw unreachableError({ url, error });
+  }
+};
+
+// src/api/public-api.ts
+var isEnvelope = (value) => Boolean(value) && typeof value === "object" && typeof value.success === "boolean";
+var callPublicApi = async ({
+  config,
+  path: path3,
+  body = {}
+}) => {
+  const url = `${config.grapeUrl}/api/v1${path3}`;
+  const response = await postRequest({ url, data: body });
+  const envelope = response.data;
+  if (!isEnvelope(envelope)) {
+    throw new CliError({
+      code: "unexpected_response",
+      message: `${url} answered ${response.status} with something that is not the Grape API envelope.`
+    });
+  }
+  if (!envelope.success) {
+    throw new CliError({
+      code: envelope.error?.code ?? "api_error",
+      message: envelope.error?.message ?? `${url} answered ${response.status}.`,
+      hint: envelope.error?.hint ?? null
+    });
+  }
+  return { data: envelope.data, meta: envelope.meta ?? {} };
+};
+
+// src/context.ts
+var contextFor = ({
+  base,
+  command
+}) => ({
+  ...base,
+  json: Boolean(command.optsWithGlobals().json)
+});
+
+// src/commands/site.ts
+var DEFAULT_RELEASES_SHOWN = 3;
+var showPlans = async ({ context }) => {
+  const { data } = await callPublicApi({
+    config: context.config,
+    path: "/plans"
+  });
+  if (context.json) return writeJson({ io: context.io, value: data });
+  const blocks = data.map(
+    (plan) => [
+      `${plan.name}  ${plan.price} ${plan.period}`,
+      `  ${plan.description}`,
+      ...plan.features.map((feature) => `  - ${feature}`),
+      `  ${plan.url}`
+    ].join("\n")
+  );
+  writeLine({ io: context.io, text: blocks.join("\n\n") });
+};
+var showChangelog = async ({
+  context,
+  platform,
+  limit
+}) => {
+  const { data } = await callPublicApi({
+    config: context.config,
+    path: "/changelog",
+    body: platform ? { platform } : {}
+  });
+  if (context.json) {
+    return writeJson({
+      io: context.io,
+      value: limit ? data.slice(0, limit) : data
+    });
+  }
+  const blocks = data.slice(0, limit ?? DEFAULT_RELEASES_SHOWN).map(
+    (release) => [
+      `${release.version}  ${release.platform}  ${release.date}`,
+      ...release.changes.map((change) => `  - ${change}`)
+    ].join("\n")
+  );
+  writeLine({ io: context.io, text: blocks.join("\n\n") });
+};
+var showDownloads = async ({
+  context,
+  kind
+}) => {
+  const { data } = await callPublicApi({
+    config: context.config,
+    path: "/downloads",
+    body: kind ? { kind } : {}
+  });
+  if (context.json) return writeJson({ io: context.io, value: data });
+  const blocks = data.map(
+    (platform) => [
+      `${platform.name}  ${platform.version}`,
+      ...platform.downloads.map(
+        (download) => `  ${download.label}  ${download.url}`
+      )
+    ].join("\n")
+  );
+  writeLine({ io: context.io, text: blocks.join("\n\n") });
+};
+var registerSiteCommands = ({
+  program,
+  base
+}) => {
+  program.command("plans").description("List the Grape plans, their prices and what each includes").action(
+    async (_options, command) => showPlans({ context: contextFor({ base, command }) })
+  );
+  program.command("changelog").description("Show what changed in the latest Grape releases").addOption(
+    new Option("--platform <platform>", "Only one app").choices([
+      "desktop",
+      "mobile"
+    ])
+  ).option("--limit <count>", "How many releases to show (default 3)").action(
+    async (options, command) => showChangelog({
+      context: contextFor({ base, command }),
+      platform: options.platform ?? null,
+      limit: parseLimit({ value: options.limit, max: 100 })
+    })
+  );
+  program.command("downloads").description("Show the download links for every platform").addOption(
+    new Option("--kind <kind>", "Only desktop or only mobile").choices([
+      "desktop",
+      "mobile"
+    ])
+  ).action(
+    async (options, command) => showDownloads({
+      context: contextFor({ base, command }),
+      kind: options.kind ?? null
+    })
+  );
+};
+
+// src/auth/oauth.ts
+var OAUTH_SCOPE = "notes:read notes:write";
+var CLIENT_NAME = "Grape CLI";
+var authorizeEndpoint = ({ config }) => `${config.grapeUrl}/oauth/authorize`;
+var tokenEndpoint = ({ config }) => `${config.grapeUrl}/api/oauth/token`;
+var registrationEndpoint = ({ config }) => `${config.grapeUrl}/api/oauth/register`;
+var describeFailure = ({
+  status,
+  data
+}) => {
+  const body = data && typeof data === "object" ? data : {};
+  return {
+    error: body.error ?? `http_${status}`,
+    description: body.error_description ?? `grape.cool answered ${status}.`
+  };
+};
+var registerClient = async ({
+  config,
+  redirectUri
+}) => {
+  const response = await postRequest({
+    url: registrationEndpoint({ config }),
+    data: {
+      client_name: CLIENT_NAME,
+      redirect_uris: [redirectUri],
+      grant_types: ["authorization_code", "refresh_token"],
+      response_types: ["code"],
+      token_endpoint_auth_method: "none"
+    }
+  });
+  const clientId = response.data?.client_id;
+  if (response.status !== 201 || typeof clientId !== "string") {
+    const { description } = describeFailure(response);
+    throw new CliError({
+      code: "registration_failed",
+      message: `Could not start the sign in: ${description}`
+    });
+  }
+  return clientId;
+};
+var buildAuthorizeUrl = ({
+  config,
+  clientId,
+  redirectUri,
+  codeChallenge,
+  state
+}) => {
+  const url = new URL(authorizeEndpoint({ config }));
+  url.search = new URLSearchParams({
+    response_type: "code",
+    client_id: clientId,
+    redirect_uri: redirectUri,
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256",
+    scope: OAUTH_SCOPE,
+    state,
+    resource: config.mcpUrl
+  }).toString();
+  return url.toString();
+};
+var toTokenSet = ({
+  data,
+  now
+}) => {
+  const { access_token, refresh_token, expires_in, scope } = data;
+  if (typeof access_token !== "string" || typeof refresh_token !== "string") {
+    return null;
+  }
+  const seconds = typeof expires_in === "number" ? expires_in : 3600;
+  return {
+    accessToken: access_token,
+    refreshToken: refresh_token,
+    expiresAt: new Date(now.getTime() + seconds * 1e3).toISOString(),
+    scope: typeof scope === "string" ? scope : OAUTH_SCOPE
+  };
+};
+var requestTokens = async ({
+  config,
+  fields,
+  now
+}) => {
+  const response = await postRequest({
+    url: tokenEndpoint({ config }),
+    data: new URLSearchParams(fields)
+  });
+  const tokens = response.status === 200 && response.data && typeof response.data === "object" ? toTokenSet({ data: response.data, now }) : null;
+  return { tokens, failure: tokens ? null : describeFailure(response) };
+};
+var exchangeCode = async ({
+  config,
+  clientId,
+  code,
+  codeVerifier,
+  redirectUri,
+  now
+}) => {
+  const { tokens, failure } = await requestTokens({
+    config,
+    now,
+    fields: {
+      grant_type: "authorization_code",
+      code,
+      code_verifier: codeVerifier,
+      client_id: clientId,
+      redirect_uri: redirectUri,
+      resource: config.mcpUrl
+    }
+  });
+  if (!tokens) {
+    throw new CliError({
+      code: failure?.error ?? "token_failed",
+      message: `The sign in did not finish: ${failure?.description}`,
+      hint: "Run grape login again."
+    });
+  }
+  return tokens;
+};
+var refreshTokens = async ({
+  config,
+  clientId,
+  refreshToken,
+  now
+}) => {
+  const { tokens, failure } = await requestTokens({
+    config,
+    now,
+    fields: {
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+      client_id: clientId,
+      resource: config.mcpUrl
+    }
+  });
+  if (tokens) return tokens;
+  if (failure?.error === "invalid_grant" || failure?.error === "invalid_client") {
+    throw signedOutError({
+      message: "Your Grape sign in has ended, so it was removed from this computer."
+    });
+  }
+  throw new CliError({
+    code: failure?.error ?? "refresh_failed",
+    message: `Could not renew the sign in: ${failure?.description}`,
+    hint: "Try again in a moment, or run grape login."
+  });
+};
+
+// src/auth/credentials.ts
+import path2 from "node:path";
+import fs2 from "node:fs/promises";
+var LOCK_WAIT_MS = 15e3;
+var LOCK_STALE_MS = 3e4;
+var LOCK_POLL_MS = 100;
+var credentialsPath = ({ config }) => path2.join(config.configDir, "credentials.json");
+var lockPath = ({ config }) => path2.join(config.configDir, "credentials.lock");
+var isCredentials = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  return [
+    "grapeUrl",
+    "mcpUrl",
+    "clientId",
+    "accessToken",
+    "refreshToken",
+    "expiresAt"
+  ].every((key) => typeof record[key] === "string" && record[key] !== "");
+};
+var readCredentials = async ({
+  config
+}) => {
+  let text;
+  try {
+    text = await fs2.readFile(credentialsPath({ config }), "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(text);
+    if (!isCredentials(parsed)) return null;
+    if (parsed.grapeUrl !== config.grapeUrl) return null;
+    if (parsed.mcpUrl !== config.mcpUrl) return null;
+    return { ...parsed, scope: parsed.scope ?? "", account: parsed.account ?? null };
+  } catch {
+    return null;
+  }
+};
+var writeCredentials = async ({
+  config,
+  credentials
+}) => {
+  const target = credentialsPath({ config });
+  const temporary = `${target}.${process.pid}.tmp`;
+  await fs2.mkdir(config.configDir, { recursive: true, mode: 448 });
+  await fs2.writeFile(temporary, `${JSON.stringify(credentials, null, 2)}
+`, {
+    mode: 384
+  });
+  await fs2.rename(temporary, target);
+};
+var deleteCredentials = async ({ config }) => {
+  try {
+    await fs2.rm(credentialsPath({ config }));
+    return true;
+  } catch {
+    return false;
+  }
+};
+var sleep = ({ ms }) => new Promise((resolve) => setTimeout(resolve, ms));
+var acquireLock = async ({ config }) => {
+  const target = lockPath({ config });
+  const deadline = Date.now() + LOCK_WAIT_MS;
+  await fs2.mkdir(config.configDir, { recursive: true, mode: 448 });
+  while (true) {
+    try {
+      const handle = await fs2.open(target, "wx", 384);
+      await handle.writeFile(String(process.pid));
+      await handle.close();
+      return;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+    const stats = await fs2.stat(target).catch(() => null);
+    if (stats && Date.now() - stats.mtimeMs > LOCK_STALE_MS) {
+      await fs2.rm(target, { force: true });
+      continue;
+    }
+    if (Date.now() > deadline) {
+      throw new CliError({
+        code: "locked",
+        message: "Another grape command is still refreshing the sign in.",
+        hint: "Try again in a moment."
+      });
+    }
+    await sleep({ ms: LOCK_POLL_MS });
+  }
+};
+var withCredentialsLock = async ({
+  config,
+  run
+}) => {
+  await acquireLock({ config });
+  try {
+    return await run();
+  } finally {
+    await fs2.rm(lockPath({ config }), { force: true });
+  }
+};
+
+// src/auth/session.ts
+var EXPIRY_MARGIN_MS = 6e4;
+var isUsable = ({
+  credentials,
+  rejectedToken,
+  now
+}) => credentials.accessToken !== rejectedToken && Date.parse(credentials.expiresAt) - EXPIRY_MARGIN_MS > now.getTime();
+var getAccessToken = async ({
+  config,
+  now,
+  rejectedToken = null
+}) => {
+  if (config.accessToken) {
+    if (rejectedToken === config.accessToken) {
+      throw new CliError({
+        code: "signed_out",
+        message: "Grape did not accept the token in GRAPE_ACCESS_TOKEN.",
+        hint: "Get a new token, or unset GRAPE_ACCESS_TOKEN and run grape login.",
+        exitCode: signedOutError().exitCode
+      });
+    }
+    return config.accessToken;
+  }
+  const stored = await readCredentials({ config });
+  if (!stored) throw signedOutError();
+  if (isUsable({ credentials: stored, rejectedToken, now })) {
+    return stored.accessToken;
+  }
+  return withCredentialsLock({
+    config,
+    run: async () => {
+      const current = await readCredentials({ config });
+      if (!current) throw signedOutError();
+      if (isUsable({ credentials: current, rejectedToken, now })) {
+        return current.accessToken;
+      }
+      try {
+        const tokens = await refreshTokens({
+          config,
+          now,
+          clientId: current.clientId,
+          refreshToken: current.refreshToken
+        });
+        await writeCredentials({ config, credentials: { ...current, ...tokens } });
+        return tokens.accessToken;
+      } catch (error) {
+        if (error instanceof CliError && error.code === "signed_out") {
+          await deleteCredentials({ config });
+        }
+        throw error;
+      }
+    }
+  });
+};
+
+// src/api/mcp.ts
+var MCP_PROTOCOL_VERSION = "2026-07-28";
+var PROTOCOL_VERSION_META_KEY = "io.modelcontextprotocol/protocolVersion";
+var CLIENT_INFO_META_KEY = "io.modelcontextprotocol/clientInfo";
+var CLIENT_CAPABILITIES_META_KEY = "io.modelcontextprotocol/clientCapabilities";
+var CLIENT_INFO = { name: "grape-cli", title: "Grape CLI", version: CLI_VERSION };
+var nextRequestId = 1;
+var buildMcpRequest = ({
+  id,
+  method,
+  params
+}) => ({
+  body: {
+    jsonrpc: "2.0",
+    id,
+    method,
+    params: {
+      ...params,
+      _meta: {
+        [PROTOCOL_VERSION_META_KEY]: MCP_PROTOCOL_VERSION,
+        [CLIENT_INFO_META_KEY]: CLIENT_INFO,
+        [CLIENT_CAPABILITIES_META_KEY]: {}
+      }
+    }
+  },
+  headers: {
+    "MCP-Protocol-Version": MCP_PROTOCOL_VERSION,
+    "Mcp-Method": method,
+    ...typeof params.name === "string" ? { "Mcp-Name": params.name } : {}
+  }
+});
+var isReply = (value) => Boolean(value) && typeof value === "object" && value.jsonrpc === "2.0" && ("result" in value || "error" in value);
+var parseJson = ({ text }) => {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+};
+var parseMcpReply = ({ body }) => {
+  const trimmed = body.trim();
+  if (!trimmed) return null;
+  const direct = parseJson({ text: trimmed });
+  if (isReply(direct)) return direct;
+  let reply = null;
+  for (const event of trimmed.split(/\r?\n\r?\n/)) {
+    const data = event.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice("data:".length).replace(/^ /, "")).join("\n");
+    const message = data ? parseJson({ text: data }) : null;
+    if (isReply(message)) reply = message;
+  }
+  return reply;
+};
+var toolText = ({ result }) => (result.content ?? []).filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n").trim();
+var send = async ({
+  context,
+  accessToken,
+  method,
+  params
+}) => {
+  const { body, headers } = buildMcpRequest({
+    id: nextRequestId++,
+    method,
+    params
+  });
+  return postRequest({
+    url: context.config.mcpUrl,
+    data: body,
+    responseType: "text",
+    headers: {
+      ...headers,
+      Authorization: `Bearer ${accessToken}`,
+      Accept: "application/json, text/event-stream"
+    }
+  });
+};
+var forbiddenError = ({ challenge }) => new CliError({
+  code: "forbidden",
+  message: challenge.includes("insufficient_scope") ? "This sign in is missing the permission this needs." : "Grape refused the request.",
+  hint: "Run grape login to sign in again."
+});
+var requestMcp = async ({
+  context,
+  method,
+  params = {},
+  accessToken
+}) => {
+  const { config } = context;
+  let token = accessToken ?? await getAccessToken({ config, now: context.now() });
+  let response = await send({ context, accessToken: token, method, params });
+  if (response.status === 401 && !accessToken) {
+    token = await getAccessToken({
+      config,
+      now: context.now(),
+      rejectedToken: token
+    });
+    response = await send({ context, accessToken: token, method, params });
+  }
+  if (response.status === 401) {
+    throw signedOutError({ message: "Grape did not accept the sign in." });
+  }
+  if (response.status === 403) {
+    throw forbiddenError({ challenge: response.headers["www-authenticate"] ?? "" });
+  }
+  const reply = parseMcpReply({ body: String(response.data ?? "") });
+  if (!reply) {
+    throw new CliError({
+      code: "unexpected_response",
+      message: `${new URL(config.mcpUrl).host} answered ${response.status} without an MCP reply.`
+    });
+  }
+  if (reply.error) {
+    throw new CliError({
+      code: "mcp_error",
+      message: reply.error.message,
+      hint: reply.error.code === -32022 ? "This version of the CLI is out of date. Update it with npm install -g @grapecool/cli." : null
+    });
+  }
+  const result = reply.result ?? {};
+  if (typeof result.resultType === "string" && result.resultType !== "complete") {
+    throw new CliError({
+      code: "unsupported_result",
+      message: `The server answered ${method} with a ${result.resultType} result, which the CLI cannot handle.`
+    });
+  }
+  return result;
+};
+var toolErrorCode = ({ text }) => {
+  if (/not on the Pro plan/i.test(text)) return "pro_required";
+  if (/too many grape calls/i.test(text)) return "rate_limited";
+  if (/does not have the notes:\w+ permission/i.test(text)) return "forbidden";
+  return "tool_error";
+};
+var callTool = async ({
+  context,
+  name,
+  args = {},
+  accessToken
+}) => {
+  const result = await requestMcp({
+    context,
+    method: "tools/call",
+    params: { name, arguments: args },
+    accessToken
+  });
+  const text = toolText({ result });
+  if (result.isError) {
+    const code = toolErrorCode({ text });
+    throw new CliError({
+      code,
+      message: text || `The ${name} tool failed.`,
+      hint: code === "forbidden" ? "Run grape login to sign in again." : null
+    });
+  }
+  return { structured: result.structuredContent ?? {}, text, result };
+};
+var listTools = async ({ context }) => {
+  const result = await requestMcp({ context, method: "tools/list" });
+  return Array.isArray(result.tools) ? result.tools : [];
+};
+
+// src/auth/pkce.ts
+import crypto from "node:crypto";
+var createPkcePair = () => {
+  const verifier = crypto.randomBytes(32).toString("base64url");
+  const challenge = crypto.createHash("sha256").update(verifier).digest("base64url");
+  return { verifier, challenge };
+};
+var createState = () => crypto.randomBytes(16).toString("base64url");
+
+// src/auth/callback.ts
+import http from "node:http";
+import readline from "node:readline";
+var CALLBACK_PATH = "/callback";
+var LOOPBACK_HOST = "127.0.0.1";
+var readAuthorizationResponse = ({
+  url,
+  state,
+  issuer
+}) => {
+  const params = url.searchParams;
+  if (params.get("state") !== state) {
+    throw new CliError({
+      code: "state_mismatch",
+      message: "That sign in answer belongs to another grape login."
+    });
+  }
+  const iss = params.get("iss");
+  if (iss !== null && iss.replace(/\/+$/, "") !== issuer) {
+    throw new CliError({
+      code: "issuer_mismatch",
+      message: `The sign in answer came from ${iss}, not ${issuer}.`
+    });
+  }
+  const error = params.get("error");
+  if (error) {
+    throw new CliError({
+      code: error,
+      message: error === "access_denied" ? "The sign in was cancelled in the browser." : `The sign in failed: ${params.get("error_description") ?? error}.`,
+      hint: "Run grape login to try again."
+    });
+  }
+  const code = params.get("code");
+  if (!code) {
+    throw new CliError({
+      code: "invalid_response",
+      message: "The sign in answer did not include a code.",
+      hint: "Run grape login to try again."
+    });
+  }
+  return code;
+};
+var escapeHtml = ({ text }) => text.replace(/[&<>"']/g, (character) => `&#${character.charCodeAt(0)};`);
+var page = ({ title, message }) => `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapeHtml({ text: title })}</title>
+<style>
+:root { --paper: #f7f1e8; --ink: #2b1d14; --muted: #6b5646; }
+@media (prefers-color-scheme: dark) { :root { --paper: #1d1510; --ink: #f7f1e8; --muted: #c9b8a8; } }
+body { margin: 0; min-height: 100vh; display: grid; place-items: center; background: var(--paper); color: var(--ink); font: 16px/1.5 -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; }
+main { max-width: 28rem; padding: 2rem 16px; text-align: center; }
+h1 { font-size: 1.5rem; margin: 0 0 0.5rem; }
+p { margin: 0; color: var(--muted); }
+</style>
+</head>
+<body><main><h1>${escapeHtml({ text: title })}</h1><p>${escapeHtml({ text: message })}</p></main></body>
+</html>`;
+var startCallbackServer = async ({
+  state,
+  issuer
+}) => {
+  let resolveCode = () => {
+  };
+  let rejectCode = () => {
+  };
+  const code = new Promise((resolve, reject) => {
+    resolveCode = resolve;
+    rejectCode = reject;
+  });
+  code.catch(() => {
+  });
+  const server = http.createServer((request, response) => {
+    const url = new URL(request.url ?? "/", `http://${LOOPBACK_HOST}`);
+    const reply = ({
+      status,
+      title,
+      message
+    }) => {
+      response.writeHead(status, {
+        "Content-Type": "text/html; charset=utf-8",
+        "Cache-Control": "no-store",
+        "Referrer-Policy": "no-referrer",
+        Connection: "close"
+      });
+      response.end(page({ title, message }));
+    };
+    if (request.method !== "GET" || url.pathname !== CALLBACK_PATH) {
+      response.writeHead(404, { "Content-Type": "text/plain", Connection: "close" });
+      response.end("Not found");
+      return;
+    }
+    try {
+      const received = readAuthorizationResponse({ url, state, issuer });
+      reply({
+        status: 200,
+        title: "Signed in to Grape",
+        message: "You can close this tab and go back to the terminal."
+      });
+      resolveCode(received);
+    } catch (error) {
+      reply({
+        status: 400,
+        title: "Not signed in",
+        message: error instanceof Error ? error.message : String(error)
+      });
+      if (!(error instanceof CliError && error.code === "state_mismatch")) {
+        rejectCode(error);
+      }
+    }
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, LOOPBACK_HOST, () => resolve());
+  });
+  const { port } = server.address();
+  return {
+    redirectUri: `http://${LOOPBACK_HOST}:${port}${CALLBACK_PATH}`,
+    code,
+    close: () => {
+      server.closeAllConnections();
+      server.close();
+    }
+  };
+};
+var waitForPastedAnswer = ({
+  io,
+  state,
+  issuer
+}) => {
+  const lines = readline.createInterface({ input: io.stdin, terminal: false });
+  const code = new Promise((resolve, reject) => {
+    lines.on("line", (line) => {
+      const pasted = line.trim();
+      if (!pasted) return;
+      let url;
+      try {
+        url = new URL(pasted);
+      } catch {
+        io.stderr("That is not an address. Paste the whole address from the browser.\n");
+        return;
+      }
+      try {
+        resolve(readAuthorizationResponse({ url, state, issuer }));
+      } catch (error) {
+        if (error instanceof CliError && error.code === "state_mismatch") {
+          io.stderr(`${error.message} Paste the address from this login.
+`);
+          return;
+        }
+        reject(error);
+      }
+    });
+  });
+  code.catch(() => {
+  });
+  return { code, close: () => lines.close() };
+};
+
+// src/auth/login.ts
+var LOGIN_TIMEOUT_MS = 10 * 6e4;
+var withTimeout = ({ promise, ms }) => {
+  let timer;
+  return Promise.race([
+    promise,
+    new Promise((_resolve, reject) => {
+      timer = setTimeout(
+        () => reject(
+          new CliError({
+            code: "timeout",
+            message: `No answer came back from the browser in ${Math.round(ms / 6e4)} minutes.`,
+            hint: "Run grape login to try again."
+          })
+        ),
+        ms
+      );
+    })
+  ]).finally(() => clearTimeout(timer));
+};
+var login = async ({
+  context,
+  openBrowser,
+  timeoutMs = LOGIN_TIMEOUT_MS
+}) => {
+  const { config, io } = context;
+  const state = createState();
+  const pkce = createPkcePair();
+  const callback = await startCallbackServer({ state, issuer: config.grapeUrl });
+  const cleanups = [callback.close];
+  try {
+    const clientId = await registerClient({
+      config,
+      redirectUri: callback.redirectUri
+    });
+    const authorizeUrl = buildAuthorizeUrl({
+      config,
+      clientId,
+      redirectUri: callback.redirectUri,
+      codeChallenge: pkce.challenge,
+      state
+    });
+    const opened = openBrowser ? await context.openUrl({ url: authorizeUrl }) : false;
+    const answers = [callback.code];
+    writeNotice({
+      io,
+      text: opened ? `Opened the Grape sign in page in your browser. If it did not open, go to:
+
+  ${authorizeUrl}
+` : `Open this page in a browser to sign in to Grape:
+
+  ${authorizeUrl}
+`
+    });
+    if (!opened && io.stdinKind === "tty") {
+      const pasted = waitForPastedAnswer({ io, state, issuer: config.grapeUrl });
+      cleanups.push(pasted.close);
+      answers.push(pasted.code);
+      writeNotice({
+        io,
+        text: "Choose Allow and this finishes by itself. If the browser is on another device, paste the address it ends up on here."
+      });
+    } else {
+      writeNotice({ io, text: "Waiting for you to choose Allow\u2026" });
+    }
+    const code = await withTimeout({ promise: Promise.race(answers), ms: timeoutMs });
+    const tokens = await exchangeCode({
+      config,
+      clientId,
+      code,
+      codeVerifier: pkce.verifier,
+      redirectUri: callback.redirectUri,
+      now: context.now()
+    });
+    const { structured: account } = await callTool({
+      context,
+      name: "get_profile",
+      accessToken: tokens.accessToken
+    });
+    const credentials = {
+      grapeUrl: config.grapeUrl,
+      mcpUrl: config.mcpUrl,
+      clientId,
+      ...tokens,
+      account: { id: account.id, name: account.name, email: account.email }
+    };
+    await withCredentialsLock({
+      config,
+      run: () => writeCredentials({ config, credentials })
+    });
+    return credentials;
+  } finally {
+    cleanups.forEach((cleanup) => cleanup());
+  }
+};
+
+// src/commands/account.ts
+var runLogin = async ({
+  context,
+  openBrowser
+}) => {
+  const credentials = await login({ context, openBrowser });
+  const account = credentials.account;
+  if (context.config.accessToken) {
+    writeNotice({
+      io: context.io,
+      text: "GRAPE_ACCESS_TOKEN is set, so commands keep using that token until you unset it."
+    });
+  }
+  if (context.json) {
+    return writeJson({
+      io: context.io,
+      value: { signedIn: true, account, scope: credentials.scope }
+    });
+  }
+  writeLine({
+    io: context.io,
+    text: `Signed in as ${account?.name} (${account?.email}).`
+  });
+};
+var runLogout = async ({ context }) => {
+  const removed = await withCredentialsLock({
+    config: context.config,
+    run: () => deleteCredentials({ config: context.config })
+  });
+  if (context.json) return writeJson({ io: context.io, value: { signedOut: removed } });
+  writeLine({
+    io: context.io,
+    text: removed ? "Signed out. The sign in was removed from this computer." : "You were not signed in on this computer."
+  });
+};
+var runWhoami = async ({ context }) => {
+  const { config } = context;
+  const { structured: account } = await callTool({
+    context,
+    name: "get_profile"
+  });
+  if (!config.accessToken) {
+    await withCredentialsLock({
+      config,
+      run: async () => {
+        const current = await readCredentials({ config });
+        if (current) {
+          await writeCredentials({
+            config,
+            credentials: {
+              ...current,
+              account: { id: account.id, name: account.name, email: account.email }
+            }
+          });
+        }
+      }
+    });
+  }
+  if (context.json) {
+    return writeJson({
+      io: context.io,
+      value: {
+        ...account,
+        grapeUrl: config.grapeUrl,
+        mcpUrl: config.mcpUrl,
+        source: config.accessToken ? "GRAPE_ACCESS_TOKEN" : credentialsPath({ config })
+      }
+    });
+  }
+  writeLine({
+    io: context.io,
+    text: `Signed in as ${account.name} (${account.email}) on ${new URL(config.grapeUrl).host}.`
+  });
+};
+var registerAccountCommands = ({
+  program,
+  base
+}) => {
+  program.command("login").description("Sign in with your Grape account in the browser").option("--no-browser", "Print the sign in page address instead of opening it").action(
+    async (options, command) => runLogin({
+      context: contextFor({ base, command }),
+      openBrowser: options.browser
+    })
+  );
+  program.command("logout").description("Remove the sign in from this computer").action(
+    async (_options, command) => runLogout({ context: contextFor({ base, command }) })
+  );
+  program.command("whoami").description("Show which Grape account the CLI is signed in to").action(
+    async (_options, command) => runWhoami({ context: contextFor({ base, command }) })
+  );
+};
+
+// src/format/text.ts
+import { isValid, parseISO, formatDistanceStrict } from "date-fns";
+var plural = ({
+  count,
+  one,
+  many
+}) => `${count} ${count === 1 ? one : many}`;
+var truncate = ({ text, max }) => text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+var singleLine = ({ text }) => text.replace(/\s+/g, " ").trim();
+var relativeTime = ({ iso, now }) => {
+  const date = parseISO(iso);
+  if (!isValid(date)) return iso;
+  return formatDistanceStrict(date, now, { addSuffix: true });
+};
+var renderTable = ({
+  headers,
+  rows
+}) => {
+  const widths = headers.map(
+    (header, index) => Math.max(header.length, ...rows.map((row) => (row[index] ?? "").length))
+  );
+  const renderRow = ({ cells }) => cells.map(
+    (cell, index) => index === cells.length - 1 ? cell : cell.padEnd(widths[index])
+  ).join("  ").trimEnd();
+  return [
+    renderRow({ cells: headers }),
+    ...rows.map((cells) => renderRow({ cells }))
+  ].join("\n");
+};
+var slugFromUrl = ({ url }) => {
+  try {
+    return new URL(url).pathname.split("/").filter(Boolean).pop() ?? url;
+  } catch {
+    return url;
+  }
+};
+
+// src/commands/markdown-input.ts
+import fs3 from "node:fs/promises";
+var readMarkdown = async ({
+  io,
+  words,
+  file
+}) => {
+  const typed = joinWords({ words });
+  if (typed && file !== void 0) {
+    throw usageError({
+      message: "Give the text as words or with --file, not both."
+    });
+  }
+  let markdown = typed;
+  if (file === "-") {
+    markdown = await readStream({ stream: io.stdin });
+  } else if (file !== void 0) {
+    try {
+      markdown = await fs3.readFile(file, "utf8");
+    } catch (error) {
+      throw usageError({
+        message: `Could not read ${file}: ${error.code ?? String(error)}.`
+      });
+    }
+  } else if (!typed && (io.stdinKind === "pipe" || io.stdinKind === "file")) {
+    markdown = await readStream({ stream: io.stdin });
+  }
+  if (!markdown.trim()) {
+    throw usageError({
+      message: "There is no text to write.",
+      hint: 'Pass it as words, with --file <path>, or on stdin: echo "# Title" | grape notes create'
+    });
+  }
+  return markdown;
+};
+var BLOCK_PLACEHOLDER = /\{\{grape-block:[A-Za-z0-9_-]+:\d+:\d+\}\}/g;
+var blockPlaceholders = ({ markdown }) => markdown.match(BLOCK_PLACEHOLDER) ?? [];
+
+// src/format/notes.ts
+var TITLE_WIDTH = 60;
+var titleOf = ({ note }) => singleLine({ text: note.title }) || "Untitled";
+var describeNote = ({ note }) => `"${titleOf({ note })}" (${note.localId})`;
+var noteLabel = ({ note }) => {
+  const marks = [
+    note.pinned ? "pinned" : null,
+    note.inRecentlyDeleted ? "in Recently Deleted" : null
+  ].filter(Boolean);
+  const title = truncate({ text: titleOf({ note }), max: TITLE_WIDTH });
+  return marks.length ? `${title} (${marks.join(", ")})` : title;
+};
+var renderNoteList = ({
+  notes,
+  now
+}) => {
+  if (notes.length === 0) return "No notes.";
+  return renderTable({
+    headers: ["ID", "UPDATED", "TITLE"],
+    rows: notes.map((note) => [
+      note.localId,
+      relativeTime({ iso: note.updatedAt, now }),
+      noteLabel({ note })
+    ])
+  });
+};
+var renderSearchHits = ({ hits }) => hits.map(
+  (hit) => [
+    `${noteLabel({ note: hit })}  ${hit.localId}`,
+    `  ${singleLine({ text: hit.snippet || hit.excerpt })}`
+  ].join("\n")
+).join("\n\n");
+var renderFolderTree = ({ folders }) => {
+  if (folders.length === 0) return "No folders.";
+  const known = new Set(folders.map((folder) => folder.localId));
+  const children = /* @__PURE__ */ new Map();
+  for (const folder of folders) {
+    const parent = folder.parentLocalId && known.has(folder.parentLocalId) ? folder.parentLocalId : null;
+    children.set(parent, [...children.get(parent) ?? [], folder]);
+  }
+  const rows = [];
+  const visited = /* @__PURE__ */ new Set();
+  const walk = ({ parent, depth }) => {
+    const siblings = [...children.get(parent) ?? []].sort(
+      (a, b) => a.order - b.order || a.name.localeCompare(b.name)
+    );
+    for (const folder of siblings) {
+      if (visited.has(folder.localId)) continue;
+      visited.add(folder.localId);
+      rows.push([
+        folder.localId,
+        String(folder.noteCount),
+        `${"  ".repeat(depth)}${singleLine({ text: folder.name })}`
+      ]);
+      walk({ parent: folder.localId, depth: depth + 1 });
+    }
+  };
+  walk({ parent: null, depth: 0 });
+  return renderTable({ headers: ["ID", "NOTES", "FOLDER"], rows });
+};
+var describeFolder = ({ folder }) => `"${singleLine({ text: folder.name })}" (${folder.localId}, ${plural({
+  count: folder.noteCount,
+  one: "note",
+  many: "notes"
+})})`;
+
+// src/commands/notes.ts
+var PAGE_SIZE = 50;
+var MAX_PAGES = 100;
+var pinnedFrom = ({ options }) => {
+  if (options.pin && options.unpin) {
+    throw usageError({ message: "Choose --pin or --unpin, not both." });
+  }
+  if (options.pin) return true;
+  if (options.unpin) return false;
+  return null;
+};
+var listNotes = async ({
+  context,
+  folder,
+  pinned,
+  deleted,
+  limit,
+  cursor,
+  all
+}) => {
+  const filters = {
+    folderLocalId: folder,
+    pinnedOnly: pinned,
+    includeRecentlyDeleted: deleted
+  };
+  const notes = [];
+  let next = cursor;
+  let pages = 0;
+  do {
+    const { structured } = await callTool({
+      context,
+      name: "list_notes",
+      args: { ...filters, cursor: next, limit: all ? PAGE_SIZE : limit ?? 20 }
+    });
+    notes.push(...structured.notes);
+    next = structured.nextCursor;
+    pages += 1;
+  } while (all && next && pages < MAX_PAGES);
+  if (context.json) {
+    return writeJson({ io: context.io, value: { notes, nextCursor: next } });
+  }
+  writeLine({ io: context.io, text: renderNoteList({ notes, now: context.now() }) });
+  if (next) {
+    writeNotice({
+      io: context.io,
+      text: `
+More notes: grape notes list --cursor ${next}${all ? "" : " (or --all)"}`
+    });
+  }
+};
+var searchNotes = async ({
+  context,
+  query,
+  limit
+}) => {
+  const { structured } = await callTool({
+    context,
+    name: "search_notes",
+    args: { query, limit }
+  });
+  if (context.json) return writeJson({ io: context.io, value: structured });
+  writeLine({
+    io: context.io,
+    text: structured.notes.length ? renderSearchHits({ hits: structured.notes }) : `No note mentions "${query}".`
+  });
+};
+var getNote = async ({
+  context,
+  localId
+}) => {
+  const { structured } = await callTool({
+    context,
+    name: "get_note",
+    args: { localId }
+  });
+  if (context.json) return writeJson({ io: context.io, value: structured });
+  const { markdown, title } = structured.note;
+  const body = markdown.trim() ? markdown : `${title || "Untitled"}
+
+(empty note)`;
+  writeLine({ io: context.io, text: body.replace(/\n+$/, "") });
+};
+var createNote = async ({
+  context,
+  markdown,
+  folder,
+  pinned
+}) => {
+  const { structured } = await callTool({
+    context,
+    name: "create_note",
+    args: { markdown, folderLocalId: folder, pinned }
+  });
+  if (context.json) return writeJson({ io: context.io, value: structured });
+  writeLine({ io: context.io, text: `Created ${describeNote({ note: structured.note })}.` });
+};
+var guardBlocks = async ({
+  context,
+  localId,
+  markdown
+}) => {
+  const { structured } = await callTool({
+    context,
+    name: "get_note",
+    args: { localId }
+  });
+  const kept = new Set(blockPlaceholders({ markdown }));
+  const dropped = blockPlaceholders({ markdown: structured.note.markdown }).filter(
+    (placeholder) => !kept.has(placeholder)
+  );
+  if (dropped.length > 0) {
+    throw new CliError({
+      code: "would_remove_blocks",
+      message: `This would remove ${plural({
+        count: dropped.length,
+        one: "block",
+        many: "blocks"
+      })} (images, drawings, decks and the like) from the note: ${dropped.join(", ")}.`,
+      hint: "Keep those lines from grape notes get in the new text, or add --force to remove them."
+    });
+  }
+};
+var updateNote = async ({
+  context,
+  localId,
+  mode,
+  markdown,
+  pinned,
+  force
+}) => {
+  if (mode === "replace" && !force) {
+    await guardBlocks({ context, localId, markdown });
+  }
+  const { structured } = await callTool({
+    context,
+    name: "update_note",
+    args: { localId, mode, markdown, pinned }
+  });
+  if (context.json) return writeJson({ io: context.io, value: structured });
+  writeLine({
+    io: context.io,
+    text: `${mode === "append" ? "Added to" : "Replaced"} ${describeNote({ note: structured.note })}.`
+  });
+};
+var moveNote = async ({
+  context,
+  localId,
+  folder
+}) => {
+  const { structured } = await callTool({
+    context,
+    name: "move_note",
+    args: { localId, folderLocalId: folder }
+  });
+  if (context.json) return writeJson({ io: context.io, value: structured });
+  writeLine({ io: context.io, text: `Moved ${describeNote({ note: structured.note })}.` });
+};
+var deleteNote = async ({
+  context,
+  localId
+}) => {
+  const { structured } = await callTool({
+    context,
+    name: "delete_note",
+    args: { localId }
+  });
+  if (context.json) return writeJson({ io: context.io, value: structured });
+  writeLine({
+    io: context.io,
+    text: `Moved ${describeNote({ note: structured.note })} to Recently Deleted. Restore it in Grape within 30 days, or with grape notes move.`
+  });
+};
+var addWriteOptions = ({
+  command,
+  canUnpin = true
+}) => {
+  command.option("--file <path>", "Read the markdown from a file, or - for stdin").option("--pin", "Pin the note");
+  return canUnpin ? command.option("--unpin", "Unpin the note") : command;
+};
+var registerNoteCommands = ({
+  program,
+  base
+}) => {
+  const notes = program.command("notes").description("Read and write the notes in your Grape account (Pro)");
+  notes.command("list").description("List notes, newest first").option("--folder <id>", "Only the notes in this folder").option("--pinned", "Only pinned notes").option("--deleted", "Include the notes in Recently Deleted").option("--limit <count>", "Notes per page, at most 50 (default 20)").option("--cursor <cursor>", "Start at the page a previous list pointed to").option("--all", "Every page, not just the first").action(
+    async (options, command) => listNotes({
+      context: contextFor({ base, command }),
+      folder: options.folder ?? null,
+      pinned: Boolean(options.pinned),
+      deleted: Boolean(options.deleted),
+      limit: parseLimit({ value: options.limit, max: 50 }),
+      cursor: options.cursor ?? null,
+      all: Boolean(options.all)
+    })
+  );
+  notes.command("search").description("Find the notes that contain a word or phrase").argument("<query...>", "What to look for").option("--limit <count>", "How many notes, at most 20 (default 10)").action(
+    async (words, options, command) => searchNotes({
+      context: contextFor({ base, command }),
+      query: joinWords({ words }),
+      limit: parseLimit({ value: options.limit, max: 20 })
+    })
+  );
+  notes.command("get").alias("read").description("Print one note as markdown").argument("<id>", "The note id, as notes list shows it").action(
+    async (localId, _options, command) => getNote({ context: contextFor({ base, command }), localId })
+  );
+  addWriteOptions({
+    command: notes.command("create").description("Create a note from markdown; the first line is its title").argument("[markdown...]", "The note text, or use --file or stdin").option("--folder <id>", "The folder to put it in (default: Notes)"),
+    canUnpin: false
+  }).action(
+    async (words, options, command) => {
+      const context = contextFor({ base, command });
+      await createNote({
+        context,
+        markdown: await readMarkdown({ io: context.io, words, file: options.file }),
+        folder: options.folder ?? null,
+        pinned: Boolean(options.pin)
+      });
+    }
+  );
+  addWriteOptions({
+    command: notes.command("append").description("Add markdown to the end of a note").argument("<id>", "The note id").argument("[markdown...]", "The text to add, or use --file or stdin")
+  }).action(async (localId, words, options, command) => {
+    const context = contextFor({ base, command });
+    await updateNote({
+      context,
+      localId,
+      mode: "append",
+      markdown: await readMarkdown({ io: context.io, words, file: options.file }),
+      pinned: pinnedFrom({ options }),
+      force: false
+    });
+  });
+  addWriteOptions({
+    command: notes.command("replace").description("Replace the whole text of a note with markdown").argument("<id>", "The note id").argument("[markdown...]", "The new text, or use --file or stdin").option("--force", "Remove the blocks whose placeholders the new text leaves out")
+  }).action(
+    async (localId, words, options, command) => {
+      const context = contextFor({ base, command });
+      await updateNote({
+        context,
+        localId,
+        mode: "replace",
+        markdown: await readMarkdown({ io: context.io, words, file: options.file }),
+        pinned: pinnedFrom({ options }),
+        force: Boolean(options.force)
+      });
+    }
+  );
+  notes.command("move").description("Move a note to another folder, which also restores a deleted one").argument("<id>", "The note id").argument("<folder-id>", "The folder id, as folders list shows it").action(
+    async (localId, folder, _options, command) => moveNote({ context: contextFor({ base, command }), localId, folder })
+  );
+  notes.command("delete").description("Move a note to Recently Deleted, restorable for 30 days").argument("<id>", "The note id").action(
+    async (localId, _options, command) => deleteNote({ context: contextFor({ base, command }), localId })
+  );
+};
+
+// src/commands/tools.ts
+var showTools = async ({ context }) => {
+  const tools = await listTools({ context });
+  if (context.json) return writeJson({ io: context.io, value: { tools } });
+  writeLine({
+    io: context.io,
+    text: renderTable({
+      headers: ["TOOL", "WHAT IT DOES"],
+      rows: tools.map((tool) => [
+        tool.name,
+        truncate({ text: singleLine({ text: tool.description ?? tool.title ?? "" }), max: 100 })
+      ])
+    })
+  });
+};
+var parseArguments = ({ text }) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw usageError({ message: "The tool arguments are not valid JSON." });
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw usageError({ message: 'The tool arguments must be a JSON object, like {"localId":"123"}.' });
+  }
+  return parsed;
+};
+var runTool = async ({
+  context,
+  name,
+  args
+}) => {
+  const { structured, text, result } = await callTool({ context, name, args });
+  if (context.json) {
+    return writeJson({
+      io: context.io,
+      value: result.structuredContent ?? { content: result.content ?? [] }
+    });
+  }
+  writeLine({
+    io: context.io,
+    text: text || JSON.stringify(structured, null, 2)
+  });
+};
+var registerToolCommands = ({
+  program,
+  base
+}) => {
+  const tools = program.command("tools").description("List and call the MCP server tools directly (Pro)");
+  tools.command("list").description("List the tools with what each one does").action(
+    async (_options, command) => showTools({ context: contextFor({ base, command }) })
+  );
+  tools.command("call").description("Call one tool with JSON arguments and print its answer").argument("<name>", "The tool name, as tools list shows it").argument("[arguments]", "The arguments as a JSON object (default {}), or - for stdin").action(async (name, json, _options, command) => {
+    const context = contextFor({ base, command });
+    const text = json === "-" ? await readStream({ stream: context.io.stdin }) : json ?? "{}";
+    await runTool({ context, name, args: parseArguments({ text }) });
+  });
+};
+
+// src/commands/guides.ts
+var isHelpArticleUrl = ({ url }) => url.includes("/help/");
+var searchGuides = async ({
+  context,
+  question,
+  limit,
+  full
+}) => {
+  const { data, meta } = await callPublicApi({
+    config: context.config,
+    path: "/help-search",
+    body: { q: question, ...limit ? { limit } : {} }
+  });
+  if (context.json) return writeJson({ io: context.io, value: { data, meta } });
+  if (data.length === 0) {
+    return writeLine({
+      io: context.io,
+      text: `No guide answers "${question}". Browse them all with grape guides list.`
+    });
+  }
+  const blocks = data.map((hit) => {
+    if (full) return [`# ${hit.title}`, "", hit.body.trim()].join("\n");
+    const lines = [hit.title, `  ${hit.summary}`, `  ${hit.url}`];
+    if (isHelpArticleUrl({ url: hit.url })) {
+      lines.push(`  grape guides read ${slugFromUrl({ url: hit.url })}`);
+    }
+    return lines.join("\n");
+  });
+  writeLine({ io: context.io, text: blocks.join("\n\n") });
+};
+var listGuides = async ({
+  context,
+  category
+}) => {
+  const { data } = await callPublicApi({
+    config: context.config,
+    path: "/help-articles",
+    body: category ? { category } : {}
+  });
+  if (context.json) return writeJson({ io: context.io, value: data });
+  writeLine({
+    io: context.io,
+    text: renderTable({
+      headers: ["SLUG", "CATEGORY", "TITLE"],
+      rows: data.map((article) => [
+        article.slug,
+        article.category,
+        truncate({ text: singleLine({ text: article.title }), max: 70 })
+      ])
+    })
+  });
+};
+var readGuide = async ({
+  context,
+  slug
+}) => {
+  const { data } = await callPublicApi({
+    config: context.config,
+    path: `/help-articles/${encodeURIComponent(slug)}`
+  });
+  if (context.json) return writeJson({ io: context.io, value: data });
+  writeLine({
+    io: context.io,
+    text: [`# ${data.title}`, "", (data.body ?? data.description).trim()].join(
+      "\n"
+    )
+  });
+};
+var registerGuideCommands = ({
+  program,
+  base
+}) => {
+  const guides = program.command("guides").description("Search and read the Grape help center, no sign in needed");
+  guides.command("search").description("Answer a how do I question from the help center").argument("<question...>", "The question, in your own words").option("--limit <count>", "How many guides to return, at most 10").option("--full", "Print each guide in full instead of a summary").action(
+    async (words, options, command) => searchGuides({
+      context: contextFor({ base, command }),
+      question: joinWords({ words }),
+      limit: parseLimit({ value: options.limit, max: 10 }),
+      full: Boolean(options.full)
+    })
+  );
+  guides.command("list").description("List every help article").option("--category <slug>", "Only the articles in one category").action(
+    async (options, command) => listGuides({
+      context: contextFor({ base, command }),
+      category: options.category ?? null
+    })
+  );
+  guides.command("read").description("Print one help article as markdown").argument("<slug>", "The article slug, as guides list or search shows it").action(
+    async (slug, _options, command) => readGuide({ context: contextFor({ base, command }), slug })
+  );
+};
+
+// src/commands/folders.ts
+var nameFrom = ({ words }) => {
+  const name = joinWords({ words });
+  if (!name) throw usageError({ message: "The folder needs a name." });
+  return name;
+};
+var listFolders = async ({ context }) => {
+  const { structured } = await callTool({
+    context,
+    name: "list_folders"
+  });
+  if (context.json) return writeJson({ io: context.io, value: structured });
+  writeLine({ io: context.io, text: renderFolderTree({ folders: structured.folders }) });
+};
+var changeFolder = async ({
+  context,
+  tool,
+  args,
+  verb
+}) => {
+  const { structured } = await callTool({
+    context,
+    name: tool,
+    args
+  });
+  if (context.json) return writeJson({ io: context.io, value: structured });
+  writeLine({ io: context.io, text: `${verb} ${describeFolder({ folder: structured.folder })}.` });
+};
+var deleteFolder = async ({
+  context,
+  localId
+}) => {
+  const { structured } = await callTool({ context, name: "delete_folder", args: { localId } });
+  if (context.json) return writeJson({ io: context.io, value: structured });
+  writeLine({
+    io: context.io,
+    text: `Deleted ${plural({
+      count: structured.deletedFolderLocalIds.length,
+      one: "folder",
+      many: "folders"
+    })} and moved ${plural({
+      count: structured.movedNoteCount,
+      one: "note",
+      many: "notes"
+    })} to Recently Deleted, where they can be restored for 30 days.`
+  });
+};
+var registerFolderCommands = ({
+  program,
+  base
+}) => {
+  const folders = program.command("folders").description("List and change the folders in your Grape account (Pro)");
+  folders.command("list").description("List every folder with its id and how many notes it holds").action(
+    async (_options, command) => listFolders({ context: contextFor({ base, command }) })
+  );
+  folders.command("create").description("Create a folder").argument("<name...>", "The folder name").option("--parent <id>", "Create it inside this folder").action(
+    async (words, options, command) => changeFolder({
+      context: contextFor({ base, command }),
+      tool: "create_folder",
+      args: { name: nameFrom({ words }), parentLocalId: options.parent ?? null },
+      verb: "Created"
+    })
+  );
+  folders.command("rename").description("Rename a folder").argument("<id>", "The folder id").argument("<name...>", "The new name").action(
+    async (localId, words, _options, command) => changeFolder({
+      context: contextFor({ base, command }),
+      tool: "update_folder",
+      args: { localId, name: nameFrom({ words }), parentLocalId: null },
+      verb: "Renamed"
+    })
+  );
+  folders.command("move").description("Move a folder into another folder, or to the top level with root").argument("<id>", "The folder id").argument("<parent-id>", "The folder to move it into, or root").action(
+    async (localId, parent, _options, command) => changeFolder({
+      context: contextFor({ base, command }),
+      tool: "update_folder",
+      args: { localId, name: null, parentLocalId: parent },
+      verb: "Moved"
+    })
+  );
+  folders.command("delete").description("Delete a folder and its subfolders; their notes go to Recently Deleted").argument("<id>", "The folder id").action(
+    async (localId, _options, command) => deleteFolder({ context: contextFor({ base, command }), localId })
+  );
+};
+
+// src/program.ts
+var EXAMPLES = `
+Examples:
+  grape login                          Sign in with your Grape account
+  grape notes list                     Your newest notes
+  grape notes search "quarterly plan"  Notes that mention a phrase
+  grape notes get 4821930571234        One note as markdown
+  echo "# Groceries" | grape notes create
+  grape folders list --json            Folders as JSON, for scripts and agents
+  grape guides search "lock a note"    Answers from the help center
+
+Notes and folders need a Grape Pro account. Plans, changelog, downloads and
+guides work without signing in. Docs: https://grape.cool/docs#cli`;
+var createProgram = ({ base }) => {
+  const program = new Command();
+  program.name("grape").description(
+    "The Grape command line: your notes and folders, and the Grape help center, from a terminal or an AI agent."
+  ).version(CLI_VERSION, "-v, --version", "Print the CLI version").option("--json", "Print JSON only, for scripts and agents").helpOption("-h, --help", "Show help for a command").helpCommand("help [command]", "Show help for a command").configureHelp({ showGlobalOptions: true }).addHelpText("after", EXAMPLES).showSuggestionAfterError().exitOverride().configureOutput({
+    writeOut: (text) => base.io.stdout(text),
+    writeErr: (text) => base.io.stderr(text)
+  });
+  registerAccountCommands({ program, base });
+  registerNoteCommands({ program, base });
+  registerFolderCommands({ program, base });
+  registerToolCommands({ program, base });
+  registerSiteCommands({ program, base });
+  registerGuideCommands({ program, base });
+  return program;
+};
+var reportError = ({
+  io,
+  error,
+  json
+}) => {
+  if (error instanceof CommanderError) {
+    return error.exitCode === 0 ? EXIT_CODES.ok : EXIT_CODES.usage;
+  }
+  if (isCliError(error)) {
+    if (json) {
+      io.stderr(
+        `${JSON.stringify({
+          error: { code: error.code, message: error.message, hint: error.hint }
+        })}
+`
+      );
+    } else {
+      writeNotice({
+        io,
+        text: [`Error: ${error.message}`, error.hint].filter(Boolean).join("\n")
+      });
+    }
+    return error.exitCode;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  if (json) {
+    io.stderr(
+      `${JSON.stringify({ error: { code: "unexpected", message, hint: null } })}
+`
+    );
+  } else {
+    writeNotice({ io, text: `Error: ${message}` });
+  }
+  if (process.env.GRAPE_DEBUG && error instanceof Error && error.stack) {
+    writeNotice({ io, text: error.stack });
+  }
+  return EXIT_CODES.failure;
+};
+var runProgram = async ({
+  argv,
+  base
+}) => {
+  const program = createProgram({ base });
+  try {
+    await program.parseAsync(argv, { from: "user" });
+    return EXIT_CODES.ok;
+  } catch (error) {
+    return reportError({ io: base.io, error, json: argv.includes("--json") });
+  }
+};
+
+// src/cli.ts
+var main = async () => {
+  const exitCode = await runProgram({
+    argv: process.argv.slice(2),
+    base: {
+      io: processIo(),
+      config: readConfig(),
+      now: () => /* @__PURE__ */ new Date(),
+      openUrl
+    }
+  });
+  process.exitCode = exitCode;
+};
+void main();