nolo-cli 0.8.0 → 0.9.0

package/agentEmailCommands-CZ3UILZ4.js

@@ -0,0 +1,626 @@
+import {
+  generateCloudflareEmailRoutingToken,
+  upsertEnvVariable
+} from "./chunk-4IJYA27C.js";
+import {
+  positionalArgs,
+  readFlagValue
+} from "./chunk-DZ3XJVET.js";
+import {
+  runAgentCreateCommand
+} from "./chunk-2K2ECKSG.js";
+import "./chunk-LARL2V6G.js";
+import "./chunk-EHLHSX7R.js";
+import {
+  getReadableCliDb
+} from "./chunk-W4NVOSFF.js";
+import {
+  fetchWithTransportFallback,
+  resolveAgentRecordFromHybridStore
+} from "./chunk-7OOXPE3N.js";
+import "./chunk-2PUGVR6E.js";
+import {
+  resolveCliAgentKeyInput
+} from "./chunk-VHBWHNVT.js";
+import "./chunk-6GANEXVO.js";
+import "./chunk-X7W4TNB4.js";
+import "./chunk-ATNTHIZI.js";
+import "./chunk-JBTJAPUF.js";
+import "./chunk-CPB2YM4D.js";
+import "./chunk-C3RUNRHT.js";
+import "./chunk-MKMWT7SA.js";
+import "./chunk-GAKEBQD6.js";
+import "./chunk-KQHGZWSV.js";
+import "./chunk-XKIMRZO2.js";
+import "./chunk-3LY4F7SV.js";
+import "./chunk-VP4WJWKW.js";
+import "./chunk-63W5N6P3.js";
+import "./chunk-UUJDGGAK.js";
+import "./chunk-PG5PNA7Y.js";
+import "./chunk-ZQ2UM4KG.js";
+import "./chunk-OWOHNGCN.js";
+import "./chunk-Q2YZULBH.js";
+import "./chunk-ZIG5LJ7X.js";
+import "./chunk-4ZDM73SD.js";
+import "./chunk-MRC4Q34M.js";
+import "./chunk-PCWC3JTN.js";
+import "./chunk-CWMSB67P.js";
+import "./chunk-4K2KKCSD.js";
+import "./chunk-KTVVPRJS.js";
+import "./chunk-Z4NR32XR.js";
+import "./chunk-M76ECQRD.js";
+import "./chunk-YYUCRDOK.js";
+import "./chunk-MGOJ5R6J.js";
+import "./chunk-UAD2WT54.js";
+import "./chunk-DCOA4QSN.js";
+import "./chunk-IDZTNRP2.js";
+import {
+  parseUserIdFromAuthToken,
+  resolveAuthToken,
+  resolveServerUrl
+} from "./chunk-ISNCLGUZ.js";
+import "./chunk-OLZBQWZU.js";
+import "./chunk-YBWOP46I.js";
+import "./chunk-5KLGBAAR.js";
+import "./chunk-ZNFJWEN4.js";
+import "./chunk-TILFE6LV.js";
+import "./chunk-XS466O7S.js";
+import "./chunk-OPZYGHUC.js";
+import "./chunk-PAKN26FP.js";
+import "./chunk-JRKKFRAV.js";
+import "./chunk-AUQ747NZ.js";
+import "./chunk-5MMAK75Q.js";
+import "./chunk-BBYVOSU2.js";
+import "./chunk-5CS33IBL.js";
+import {
+  createOAuthTokenStore
+} from "./chunk-JZPBVBIY.js";
+import "./chunk-IWX4UW2E.js";
+import "./chunk-5MIDPSSK.js";
+import "./chunk-DFFIZ25G.js";
+import "./chunk-3ASDTTEI.js";
+import "./chunk-DWLEOOGR.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import "./chunk-H33743XH.js";
+import "./chunk-LM6IYQ3F.js";
+import "./chunk-63SLEOLK.js";
+import "./chunk-TSS3XJY4.js";
+import "./chunk-Y5GCAMGP.js";
+import "./chunk-COMXDWNM.js";
+import "./chunk-AZPCASRE.js";
+import "./chunk-2EISRLRC.js";
+import "./chunk-KX6YBIHG.js";
+import {
+  createAgentKey
+} from "./chunk-SH2CFQOH.js";
+import "./chunk-I42VC5KR.js";
+import "./chunk-WWC7I6TA.js";
+import "./chunk-QSJ3HFEF.js";
+import "./chunk-ELRRLDWI.js";
+import "./chunk-EYEEHCU4.js";
+import "./chunk-QYXLLLGL.js";
+import "./chunk-GBRG75BQ.js";
+import "./chunk-4SN6J65J.js";
+import "./chunk-LCBAMY2M.js";
+import "./chunk-3EUW3WEO.js";
+import "./chunk-U6VC4MU4.js";
+import "./chunk-CF7PE763.js";
+import "./chunk-G3SUCT4W.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+import "./chunk-4VNS5WPM.js";
+
+// packages/cli/agentEmailRpc.ts
+function readRpcErrorMessage(body, status) {
+  if (isRecord(body) && "message" in body) {
+    const message = body.message;
+    if (typeof message === "string" && message.trim()) {
+      return message;
+    }
+  }
+  return `RPC failed (${status})`;
+}
+function readOptionalString(body, key) {
+  const value = body[key];
+  return typeof value === "string" ? value : void 0;
+}
+function readNullableString(body, key) {
+  const value = body[key];
+  if (value === null || value === void 0) return null;
+  return typeof value === "string" ? value : null;
+}
+function parseAgentEmailIdentityRpcData(body) {
+  if (!isRecord(body)) {
+    throw new Error("RPC response was not a JSON object");
+  }
+  const agentId = body.agentId;
+  const emailAddress = body.emailAddress;
+  if (typeof agentId !== "string" || !agentId.trim()) {
+    throw new Error("RPC response missing agentId");
+  }
+  if (typeof emailAddress !== "string" || !emailAddress.trim()) {
+    throw new Error("RPC response missing emailAddress");
+  }
+  const parsed = {
+    agentId,
+    emailAddress,
+    readinessStatus: readNullableString(body, "readinessStatus"),
+    ingressReadyAt: readNullableString(body, "ingressReadyAt"),
+    lastWarmupAt: readNullableString(body, "lastWarmupAt"),
+    lastWarmupError: readNullableString(body, "lastWarmupError")
+  };
+  const localPart = readOptionalString(body, "localPart");
+  const domain = readOptionalString(body, "domain");
+  const provider = readOptionalString(body, "provider");
+  const delegationResourcePrefix = readOptionalString(
+    body,
+    "delegationResourcePrefix"
+  );
+  if (localPart) parsed.localPart = localPart;
+  if (domain) parsed.domain = domain;
+  if (provider) parsed.provider = provider;
+  if ("purpose" in body) {
+    const purpose = body.purpose;
+    parsed.purpose = purpose === null || purpose === void 0 ? null : typeof purpose === "string" ? purpose : null;
+  }
+  if (delegationResourcePrefix) {
+    parsed.delegationResourcePrefix = delegationResourcePrefix;
+  }
+  return parsed;
+}
+function readAgentRecordFromRpcBody(body) {
+  if (!isRecord(body) || !("agent" in body)) {
+    throw new Error("RPC response missing agent record");
+  }
+  const agent = body.agent;
+  if (!isRecord(agent)) {
+    throw new Error("RPC response agent field is invalid");
+  }
+  return agent;
+}
+async function resolveAgentIdForEmailRpc(args) {
+  const resolvedInput = resolveCliAgentKeyInput(args.agentInput);
+  if (resolvedInput.startsWith("agent-")) {
+    return resolvedInput;
+  }
+  const userId = parseUserIdFromAuthToken(args.authToken);
+  if (!userId) {
+    throw new Error("Could not read userId from auth token");
+  }
+  const resolved = await resolveAgentRecordFromHybridStore({
+    agentInput: args.agentInput,
+    cliArgs: args.cliArgs,
+    env: args.env,
+    db: args.db,
+    fetchImpl: args.fetchImpl,
+    fallbackFetchImpl: args.fallbackFetchImpl
+  });
+  if (resolved?.agentKey) {
+    return resolved.agentKey;
+  }
+  return createAgentKey.private(userId, resolvedInput);
+}
+async function postAgentEmailRpc(args) {
+  const baseUrl = args.cliArgs ? resolveServerUrl(args.cliArgs, args.env) : resolveServerUrl(args.env);
+  const url = `${baseUrl}/rpc/${args.method}`;
+  const response = await fetchWithTransportFallback(
+    url,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${args.authToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(args.body)
+    },
+    {
+      fetchImpl: args.fetchImpl,
+      fallbackFetchImpl: args.fallbackFetchImpl
+    }
+  );
+  const raw = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw new Error(readRpcErrorMessage(raw, response.status));
+  }
+  const data = parseAgentEmailIdentityRpcData(raw);
+  const agent = readAgentRecordFromRpcBody(raw);
+  return { data, agent, baseUrl };
+}
+
+// packages/cli/agentEmailCommands.ts
+var PROVISION_USAGE = "Usage: nolo agent email provision <agent> [--purpose <label>] [--local-part <part>] [--domain <domain>] [--provider <name>] [--no-primary] [--cloudflare-oauth]\n";
+var BIND_USAGE = "Usage: nolo agent email bind <agent> --email <address> [--provider <name>] [--cloudflare-oauth]\n";
+var TRANSFER_USAGE = "Usage: nolo agent email transfer --from <source-agent> --to <target-agent> --email <address> [--no-move-history] [--primary|--no-primary] [--cloudflare-oauth]\n  \u6CE8\u610F\uFF1Atransfer \u4E0D\u662F\u4E8B\u52A1\u64CD\u4F5C\uFF0C\u4E2D\u9014\u5931\u8D25\u53EF\u80FD\u7559\u4E0B\u90E8\u5206\u8FC1\u79FB\u72B6\u6001\uFF0C\u9700\u4EBA\u5DE5\u6838\u67E5\u3002\n";
+function wantsHelp(args) {
+  return args.includes("--help") || args.includes("-h");
+}
+async function ensureCloudflareEmailRoutingToken(args, env, output) {
+  const existing = env.CLOUDFLARE_EMAIL_ROUTING_API_TOKEN?.trim();
+  if (existing) {
+    return { token: existing, wasGenerated: false };
+  }
+  if (!args.includes("--cloudflare-oauth")) {
+    return null;
+  }
+  const credential = createOAuthTokenStore().read("cloudflare");
+  if (!credential) {
+    throw new Error(
+      "No Cloudflare OAuth credential. Run: nolo auth cloudflare --client-id <id>"
+    );
+  }
+  const zoneName = env.CLOUDFLARE_ZONE_NAME?.trim() ?? "nolo.chat";
+  const tokenName = `nolo-email-routing-${zoneName}`;
+  const { token } = await generateCloudflareEmailRoutingToken({
+    accessToken: credential.accessToken,
+    zoneName,
+    tokenName
+  });
+  upsertEnvVariable(".env", "CLOUDFLARE_EMAIL_ROUTING_API_TOKEN", token);
+  output.write(
+    "[nolo] Generated CLOUDFLARE_EMAIL_ROUTING_API_TOKEN and updated .env.\n"
+  );
+  output.write(
+    "[nolo] If your server is already running, restart it so the new token takes effect.\n"
+  );
+  return { token, wasGenerated: true };
+}
+function resolveAgentInput(args) {
+  return readFlagValue(args, "--agent") ?? positionalArgs(args)[0]?.trim();
+}
+async function runAgentEmailProvisionCommand(args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  if (wantsHelp(args) || args.length === 0) {
+    output.write(PROVISION_USAGE);
+    return args.length === 0 ? 1 : 0;
+  }
+  const agentInput = resolveAgentInput(args);
+  if (!agentInput) {
+    output.write(PROVISION_USAGE);
+    return 1;
+  }
+  const authToken = resolveAuthToken(args, env);
+  if (!authToken) {
+    output.write(
+      "[nolo] agent email provision requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n"
+    );
+    return 1;
+  }
+  const userId = parseUserIdFromAuthToken(authToken);
+  if (!userId) {
+    output.write(
+      "[nolo] agent email provision could not read userId from AUTH_TOKEN.\n"
+    );
+    return 1;
+  }
+  const purpose = readFlagValue(args, "--purpose");
+  const localPart = readFlagValue(args, "--local-part");
+  const domain = readFlagValue(args, "--domain");
+  const provider = readFlagValue(args, "--provider");
+  const makePrimary = !args.includes("--no-primary");
+  const db = deps.db ?? await getReadableCliDb(output);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fallbackFetchImpl = deps.fallbackFetchImpl;
+  try {
+    const tokenResult = await ensureCloudflareEmailRoutingToken(args, env, output);
+    if (tokenResult?.wasGenerated) {
+      env.CLOUDFLARE_EMAIL_ROUTING_API_TOKEN = tokenResult.token;
+    }
+    const agentId = await resolveAgentIdForEmailRpc({
+      agentInput,
+      cliArgs: args,
+      env,
+      db,
+      authToken,
+      fetchImpl,
+      fallbackFetchImpl
+    });
+    const result = await postAgentEmailRpc({
+      method: "provisionAgentEmailIdentity",
+      body: {
+        agentId,
+        ...purpose ? { purpose } : {},
+        ...localPart ? { localPart } : {},
+        ...domain ? { domain } : {},
+        ...provider ? { provider } : {},
+        makePrimary
+      },
+      cliArgs: args,
+      env,
+      authToken,
+      fetchImpl,
+      fallbackFetchImpl
+    });
+    await db.put(agentId, {
+      ...result.agent,
+      dbKey: agentId,
+      key: agentId,
+      serverOrigin: result.baseUrl,
+      cachedAt: Date.now()
+    });
+    output.write(
+      JSON.stringify(
+        {
+          ok: true,
+          action: "provision",
+          agentId: result.data.agentId,
+          emailAddress: result.data.emailAddress,
+          localPart: result.data.localPart,
+          domain: result.data.domain,
+          provider: result.data.provider,
+          purpose: result.data.purpose,
+          readinessStatus: result.data.readinessStatus,
+          baseUrl: result.baseUrl
+        },
+        null,
+        2
+      )
+    );
+    output.write("\n");
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] agent email provision failed: ${toErrorMessage(error)}
+`
+    );
+    return 1;
+  }
+}
+async function runAgentEmailBindCommand(args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  if (wantsHelp(args) || args.length === 0) {
+    output.write(BIND_USAGE);
+    return args.length === 0 ? 1 : 0;
+  }
+  const agentInput = resolveAgentInput(args);
+  const emailAddress = readFlagValue(args, "--email")?.trim();
+  if (!agentInput || !emailAddress) {
+    output.write(BIND_USAGE);
+    return 1;
+  }
+  const authToken = resolveAuthToken(args, env);
+  if (!authToken) {
+    output.write(
+      "[nolo] agent email bind requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n"
+    );
+    return 1;
+  }
+  const userId = parseUserIdFromAuthToken(authToken);
+  if (!userId) {
+    output.write(
+      "[nolo] agent email bind could not read userId from AUTH_TOKEN.\n"
+    );
+    return 1;
+  }
+  const provider = readFlagValue(args, "--provider");
+  const db = deps.db ?? await getReadableCliDb(output);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fallbackFetchImpl = deps.fallbackFetchImpl;
+  try {
+    const tokenResult = await ensureCloudflareEmailRoutingToken(args, env, output);
+    if (tokenResult?.wasGenerated) {
+      env.CLOUDFLARE_EMAIL_ROUTING_API_TOKEN = tokenResult.token;
+    }
+    const agentId = await resolveAgentIdForEmailRpc({
+      agentInput,
+      cliArgs: args,
+      env,
+      db,
+      authToken,
+      fetchImpl,
+      fallbackFetchImpl
+    });
+    const result = await postAgentEmailRpc({
+      method: "bindAgentEmailIdentity",
+      body: {
+        agentId,
+        emailAddress,
+        ...provider ? { provider } : {}
+      },
+      cliArgs: args,
+      env,
+      authToken,
+      fetchImpl,
+      fallbackFetchImpl
+    });
+    await db.put(agentId, {
+      ...result.agent,
+      dbKey: agentId,
+      key: agentId,
+      serverOrigin: result.baseUrl,
+      cachedAt: Date.now()
+    });
+    output.write(
+      JSON.stringify(
+        {
+          ok: true,
+          action: "bind",
+          agentId: result.data.agentId,
+          emailAddress: result.data.emailAddress,
+          readinessStatus: result.data.readinessStatus,
+          baseUrl: result.baseUrl
+        },
+        null,
+        2
+      )
+    );
+    output.write("\n");
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] agent email bind failed: ${toErrorMessage(error)}
+`
+    );
+    return 1;
+  }
+}
+async function runAgentEmailTransferCommand(args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  if (wantsHelp(args) || args.length === 0) {
+    output.write(TRANSFER_USAGE);
+    return args.length === 0 ? 1 : 0;
+  }
+  const sourceInput = readFlagValue(args, "--from")?.trim();
+  const targetInput = readFlagValue(args, "--to")?.trim();
+  const emailAddress = readFlagValue(args, "--email")?.trim();
+  if (!sourceInput || !targetInput || !emailAddress) {
+    output.write(TRANSFER_USAGE);
+    return 1;
+  }
+  const authToken = resolveAuthToken(args, env);
+  if (!authToken) {
+    output.write(
+      "[nolo] agent email transfer requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n"
+    );
+    return 1;
+  }
+  const userId = parseUserIdFromAuthToken(authToken);
+  if (!userId) {
+    output.write(
+      "[nolo] agent email transfer could not read userId from AUTH_TOKEN.\n"
+    );
+    return 1;
+  }
+  const moveHistoryEmails = !args.includes("--no-move-history");
+  const makePrimary = args.includes("--primary") ? true : args.includes("--no-primary") ? false : void 0;
+  const db = deps.db ?? await getReadableCliDb(output);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fallbackFetchImpl = deps.fallbackFetchImpl;
+  try {
+    const tokenResult = await ensureCloudflareEmailRoutingToken(args, env, output);
+    if (tokenResult?.wasGenerated) {
+      env.CLOUDFLARE_EMAIL_ROUTING_API_TOKEN = tokenResult.token;
+    }
+    const [sourceAgentId, targetAgentId] = await Promise.all([
+      resolveAgentIdForEmailRpc({
+        agentInput: sourceInput,
+        cliArgs: args,
+        env,
+        db,
+        authToken,
+        fetchImpl,
+        fallbackFetchImpl
+      }),
+      resolveAgentIdForEmailRpc({
+        agentInput: targetInput,
+        cliArgs: args,
+        env,
+        db,
+        authToken,
+        fetchImpl,
+        fallbackFetchImpl
+      })
+    ]);
+    const result = await postAgentEmailRpc({
+      method: "transferAgentEmailIdentity",
+      body: {
+        sourceAgentId,
+        targetAgentId,
+        emailAddress,
+        moveHistoryEmails,
+        ...makePrimary === void 0 ? {} : { makePrimary }
+      },
+      cliArgs: args,
+      env,
+      authToken,
+      fetchImpl,
+      fallbackFetchImpl
+    });
+    await db.put(targetAgentId, {
+      ...result.agent,
+      dbKey: targetAgentId,
+      key: targetAgentId,
+      serverOrigin: result.baseUrl,
+      cachedAt: Date.now()
+    });
+    output.write(
+      JSON.stringify(
+        {
+          ok: true,
+          action: "transfer",
+          sourceAgentId: result.data.sourceAgentId,
+          targetAgentId: result.data.targetAgentId,
+          emailAddress: result.data.emailAddress,
+          movedEmails: result.data.movedEmails,
+          delegationResourcePrefix: result.data.delegationResourcePrefix,
+          baseUrl: result.baseUrl
+        },
+        null,
+        2
+      )
+    );
+    output.write("\n");
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] agent email transfer failed: ${toErrorMessage(error)}
+`
+    );
+    return 1;
+  }
+}
+async function runAgentEmailCreateAndProvisionCommand(args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  if (wantsHelp(args)) {
+    output.write(
+      "Usage: nolo agent email create-and-provision <agent-id-or-slug> --name <display name> [--prompt <text>] [--copy-provider-from <agent>] [--purpose <label>] [--local-part <part>] [--domain <domain>] [--provider <name>]\n"
+    );
+    return 0;
+  }
+  const agentSlug = resolveAgentInput(args);
+  const name = readFlagValue(args, "--name")?.trim();
+  if (!agentSlug || !name) {
+    output.write(
+      "[nolo] agent email create-and-provision requires <agent> and --name.\n"
+    );
+    output.write(
+      "Usage: nolo agent email create-and-provision <agent> --name <display name> [--prompt <text>] [--copy-provider-from <agent>] [--purpose <label>] [--local-part pay]\n"
+    );
+    return 1;
+  }
+  const createArgs = [agentSlug, "--name", name];
+  const prompt = readFlagValue(args, "--prompt");
+  const copyFrom = readFlagValue(args, "--copy-provider-from");
+  if (prompt) {
+    createArgs.push("--prompt", prompt);
+  }
+  if (copyFrom) {
+    createArgs.push("--copy-provider-from", copyFrom);
+  }
+  const createExit = await runAgentCreateCommand(createArgs, deps);
+  if (createExit !== 0) {
+    return createExit;
+  }
+  const provisionArgs = [agentSlug];
+  for (const flag of [
+    "--purpose",
+    "--local-part",
+    "--domain",
+    "--provider",
+    "--server",
+    "--server-url",
+    "--token",
+    "--machine-key"
+  ]) {
+    const value = readFlagValue(args, flag);
+    if (value) {
+      provisionArgs.push(flag, value);
+    }
+  }
+  if (args.includes("--no-primary")) {
+    provisionArgs.push("--no-primary");
+  }
+  return runAgentEmailProvisionCommand(provisionArgs, deps);
+}
+export {
+  runAgentEmailBindCommand,
+  runAgentEmailCreateAndProvisionCommand,
+  runAgentEmailProvisionCommand,
+  runAgentEmailTransferCommand
+};