nolo-cli 0.8.0 → 0.9.0

package/chunk-3TZDXYSF.js

@@ -0,0 +1,71 @@
+import {
+  createMemoryKey,
+  createMemoryOwnerIndexKey,
+  createMemorySubjectKindIndexKey,
+  ulid
+} from "./chunk-SH2CFQOH.js";
+
+// packages/ai/memory/storeShared.ts
+var createMemoryItem = (input) => {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: ulid(),
+    createdAt: now,
+    lastActivatedAt: now,
+    activationCount: 0,
+    ...input
+  };
+};
+var writeMemoryItemWithIndexesToDb = async (db, item) => {
+  const batch = db.batch();
+  batch.put(createMemoryKey(item.ownerType, item.ownerId, item.id), item);
+  batch.put(
+    createMemoryOwnerIndexKey(
+      item.ownerType,
+      item.ownerId,
+      item.createdAt,
+      item.id
+    ),
+    {
+      memoryKey: createMemoryKey(item.ownerType, item.ownerId, item.id),
+      ownerType: item.ownerType,
+      ownerId: item.ownerId,
+      memoryId: item.id
+    }
+  );
+  batch.put(
+    createMemorySubjectKindIndexKey(
+      item.subjectType,
+      item.subjectId,
+      item.kind,
+      item.createdAt,
+      item.id
+    ),
+    {
+      memoryKey: createMemoryKey(item.ownerType, item.ownerId, item.id),
+      subjectType: item.subjectType,
+      subjectId: item.subjectId,
+      kind: item.kind,
+      memoryId: item.id
+    }
+  );
+  await batch.write();
+};
+var touchMemoryItemsInDb = async (db, items, now = (/* @__PURE__ */ new Date()).toISOString()) => {
+  if (items.length === 0) return;
+  const batch = db.batch();
+  for (const item of items) {
+    batch.put(createMemoryKey(item.ownerType, item.ownerId, item.id), {
+      ...item,
+      lastActivatedAt: now,
+      activationCount: (item.activationCount ?? 0) + 1
+    });
+  }
+  await batch.write();
+};
+
+export {
+  createMemoryItem,
+  writeMemoryItemWithIndexesToDb,
+  touchMemoryItemsInDb
+};

package/chunk-3WYQEUBI.js

@@ -0,0 +1,34 @@
+import {
+  fetchReferenceContents,
+  resolveReferenceAssets
+} from "./chunk-SBR32ZZS.js";
+
+// packages/ai/agent/fetchAgentContexts.ts
+async function fetchAgentContexts(references, dispatch) {
+  if (!Array.isArray(references)) {
+    return { botInstructionsContext: "", botKnowledgeContext: "" };
+  }
+  const { references: normalizedRefs, contentByKey } = await resolveReferenceAssets(references, dispatch);
+  const instructionKeys = /* @__PURE__ */ new Set();
+  const knowledgeKeys = /* @__PURE__ */ new Set();
+  normalizedRefs.forEach((ref) => {
+    if (!ref.dbKey) return;
+    ref.type === "instruction" ? instructionKeys.add(ref.dbKey) : knowledgeKeys.add(ref.dbKey);
+  });
+  const [instructionsMap, knowledgeMap] = await Promise.all([
+    fetchReferenceContents(Array.from(instructionKeys), dispatch, {
+      preloaded: contentByKey
+    }),
+    fetchReferenceContents(Array.from(knowledgeKeys), dispatch, {
+      preloaded: contentByKey
+    })
+  ]);
+  return {
+    botInstructionsContext: Array.from(instructionsMap.values()).join(""),
+    botKnowledgeContext: Array.from(knowledgeMap.values()).join("")
+  };
+}
+
+export {
+  fetchAgentContexts
+};

package/chunk-4CQLVGRV.js

@@ -0,0 +1,50 @@
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+
+// packages/cli/cliSpaceHelpers.ts
+function normalizeSpaceIdInput(rawInput) {
+  const raw = rawInput.trim();
+  if (!raw) return "";
+  let candidate = raw;
+  if (raw.startsWith("http://") || raw.startsWith("https://")) {
+    const match = new URL(raw).pathname.match(/^\/space\/([^/?#]+)/);
+    if (!match?.[1]) return "";
+    candidate = decodeURIComponent(match[1]);
+  }
+  return candidate.startsWith("space-") ? candidate.slice("space-".length) : candidate;
+}
+function buildSpaceLookup(rawInput) {
+  const spaceId = normalizeSpaceIdInput(rawInput);
+  return {
+    spaceId,
+    spaceKey: spaceId ? `space-${spaceId}` : ""
+  };
+}
+function getSpaceContentKeys(spaceRecord) {
+  const keys = /* @__PURE__ */ new Set();
+  const contents = spaceRecord?.contents;
+  if (!contents || typeof contents !== "object") return keys;
+  for (const [entryKey, value] of Object.entries(contents)) {
+    const trimmedEntryKey = asOptionalTrimmedString(entryKey);
+    if (trimmedEntryKey) {
+      keys.add(trimmedEntryKey);
+    }
+    if (isRecord(value)) {
+      const contentKey = asOptionalTrimmedString(value.contentKey);
+      if (contentKey) {
+        keys.add(contentKey);
+      }
+    }
+  }
+  return keys;
+}
+
+export {
+  normalizeSpaceIdInput,
+  buildSpaceLookup,
+  getSpaceContentKeys
+};

package/chunk-4IJYA27C.js

@@ -0,0 +1,342 @@
+import {
+  generatePkcePair,
+  startCallbackServer
+} from "./chunk-EHLHSX7R.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import {
+  asOptionalFiniteNumber
+} from "./chunk-WWC7I6TA.js";
+
+// packages/cli/oauth/flows/cloudflare.ts
+var CLOUDFLARE_OAUTH_AUTH_ENDPOINT = "https://dash.cloudflare.com/oauth2/auth";
+var CLOUDFLARE_OAUTH_TOKEN_ENDPOINT = "https://dash.cloudflare.com/oauth2/token";
+var CLOUDFLARE_API_BASE = "https://api.cloudflare.com/client/v4";
+var CLOUDFLARE_OAUTH_REDIRECT_HOST = "127.0.0.1";
+var CLOUDFLARE_OAUTH_REDIRECT_PORT = 56122;
+var CLOUDFLARE_OAUTH_REDIRECT_PATH = "/callback";
+var ACCESS_TOKEN_CLIENT_SKEW_MS = 5 * 60 * 1e3;
+var TOKEN_REQUEST_TIMEOUT_MS = 2e4;
+var DEFAULT_SCOPE = "account:read zone:read zone:edit user:read user:edit";
+function generateState() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((value) => value.toString(16).padStart(2, "0")).join("");
+}
+function getClientId(args) {
+  const value = args?.clientId?.trim() || process.env.CLOUDFLARE_OAUTH_CLIENT_ID?.trim();
+  if (!value) {
+    throw new Error(
+      "Cloudflare OAuth client ID is required. Set CLOUDFLARE_OAUTH_CLIENT_ID or pass --client-id."
+    );
+  }
+  return value;
+}
+function getScope(args) {
+  return args?.scope?.trim() || process.env.CLOUDFLARE_OAUTH_SCOPE?.trim() || DEFAULT_SCOPE;
+}
+function buildCloudflareAuthorizeUrl(opts) {
+  const params = new URLSearchParams({
+    response_type: "code",
+    client_id: opts.clientId,
+    redirect_uri: opts.redirectUri,
+    scope: opts.scope,
+    code_challenge: opts.codeChallenge,
+    code_challenge_method: "S256",
+    state: opts.state
+  });
+  return `${CLOUDFLARE_OAUTH_AUTH_ENDPOINT}?${params.toString()}`;
+}
+async function exchangeCloudflareToken(fetchImpl, code, redirectUri, verifier, clientId) {
+  const body = new URLSearchParams({
+    grant_type: "authorization_code",
+    client_id: clientId,
+    code,
+    redirect_uri: redirectUri,
+    code_verifier: verifier
+  });
+  const response = await fetchImpl(CLOUDFLARE_OAUTH_TOKEN_ENDPOINT, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Accept: "application/json"
+    },
+    body,
+    signal: AbortSignal.timeout(TOKEN_REQUEST_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    let detail = "";
+    try {
+      detail = (await response.text()).trim();
+    } catch {
+    }
+    throw new Error(
+      `Cloudflare token exchange failed: ${response.status}${detail ? ` ${detail}` : ""}`
+    );
+  }
+  const data = await response.json();
+  if (typeof data.access_token !== "string" || !data.access_token) {
+    throw new Error("Cloudflare token exchange response missing access_token");
+  }
+  return {
+    accessToken: data.access_token,
+    refreshToken: typeof data.refresh_token === "string" ? data.refresh_token : void 0,
+    expiresIn: asOptionalFiniteNumber(data.expires_in),
+    scope: typeof data.scope === "string" ? data.scope : void 0,
+    idToken: typeof data.id_token === "string" ? data.id_token : void 0
+  };
+}
+async function runCloudflareOAuthLogin(deps = {}) {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const output = deps.output ?? console;
+  const error = deps.error ?? console;
+  const clientId = getClientId(deps);
+  const scope = getScope(deps);
+  const redirectUri = `http://${CLOUDFLARE_OAUTH_REDIRECT_HOST}:${CLOUDFLARE_OAUTH_REDIRECT_PORT}${CLOUDFLARE_OAUTH_REDIRECT_PATH}`;
+  let handle;
+  try {
+    handle = await startCallbackServer({
+      port: CLOUDFLARE_OAUTH_REDIRECT_PORT,
+      hostname: CLOUDFLARE_OAUTH_REDIRECT_HOST,
+      timeoutMs: 5 * 6e4
+    });
+  } catch (err) {
+    throw new Error(
+      `Failed to start Cloudflare OAuth callback server on ${CLOUDFLARE_OAUTH_REDIRECT_PORT}: ${toErrorMessage(err)}`
+    );
+  }
+  try {
+    const state = generateState();
+    const pkce = await generatePkcePair();
+    const authUrl = buildCloudflareAuthorizeUrl({
+      redirectUri,
+      codeChallenge: pkce.challenge,
+      state,
+      clientId,
+      scope
+    });
+    output.log(
+      `Open the following URL in your browser to authorize Cloudflare access:
+  ${authUrl}
+
+Requested scopes: ${scope}`
+    );
+    if (deps.openBrowser) {
+      try {
+        await deps.openBrowser(authUrl);
+      } catch (err) {
+        error.error(
+          `Failed to open browser automatically: ${toErrorMessage(err)}`
+        );
+      }
+    }
+    const callback = await handle.waitForCode();
+    const token = await exchangeCloudflareToken(
+      fetchImpl,
+      callback.code,
+      redirectUri,
+      pkce.verifier,
+      clientId
+    );
+    const now = (deps.now ?? Date.now)();
+    const expiresIn = token.expiresIn;
+    return {
+      provider: "cloudflare",
+      accessToken: token.accessToken,
+      refreshToken: token.refreshToken,
+      expiresAt: typeof expiresIn === "number" ? now + expiresIn * 1e3 - ACCESS_TOKEN_CLIENT_SKEW_MS : void 0,
+      scope: token.scope,
+      idToken: token.idToken,
+      obtainedAt: now
+    };
+  } finally {
+    await handle.close();
+  }
+}
+async function createCloudflareApiToken(input) {
+  const fetchImpl = input.fetchImpl ?? fetch;
+  const response = await fetchImpl(`${CLOUDFLARE_API_BASE}/user/tokens`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${input.accessToken}`
+    },
+    body: JSON.stringify({
+      name: input.name,
+      policies: input.policies
+    }),
+    signal: AbortSignal.timeout(TOKEN_REQUEST_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    let detail = "";
+    try {
+      detail = (await response.text()).trim();
+    } catch {
+    }
+    throw new Error(
+      `Cloudflare API token creation failed: ${response.status}${detail ? ` ${detail}` : ""}`
+    );
+  }
+  const data = await response.json();
+  const tokenValue = data.result?.value;
+  if (typeof tokenValue !== "string" || !tokenValue) {
+    throw new Error(
+      "Cloudflare API token creation response did not contain a token value"
+    );
+  }
+  return tokenValue;
+}
+async function listCloudflarePermissionGroups(accessToken, fetchImpl = fetch) {
+  const response = await fetchImpl(
+    `${CLOUDFLARE_API_BASE}/user/tokens/permission_groups`,
+    {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: "application/json"
+      },
+      signal: AbortSignal.timeout(TOKEN_REQUEST_TIMEOUT_MS)
+    }
+  );
+  if (!response.ok) {
+    let detail = "";
+    try {
+      detail = (await response.text()).trim();
+    } catch {
+    }
+    throw new Error(
+      `Cloudflare permission groups lookup failed: ${response.status}${detail ? ` ${detail}` : ""}`
+    );
+  }
+  const data = await response.json();
+  if (!Array.isArray(data.result)) {
+    throw new Error("Cloudflare permission groups response missing result array");
+  }
+  return data.result.filter(
+    (group) => typeof group.id === "string" && typeof group.name === "string" && Array.isArray(group.permissions)
+  ).map((group) => ({
+    id: group.id,
+    name: group.name,
+    permissions: group.permissions
+  }));
+}
+async function findCloudflareZoneIdByName(accessToken, zoneName, fetchImpl = fetch) {
+  const response = await fetchImpl(
+    `${CLOUDFLARE_API_BASE}/zones?name=${encodeURIComponent(zoneName)}`,
+    {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: "application/json"
+      },
+      signal: AbortSignal.timeout(TOKEN_REQUEST_TIMEOUT_MS)
+    }
+  );
+  if (!response.ok) {
+    let detail = "";
+    try {
+      detail = (await response.text()).trim();
+    } catch {
+    }
+    throw new Error(
+      `Cloudflare zone lookup failed: ${response.status}${detail ? ` ${detail}` : ""}`
+    );
+  }
+  const data = await response.json();
+  if (!Array.isArray(data.result)) {
+    throw new Error("Cloudflare zone lookup response missing result array");
+  }
+  const zone = data.result.find((z) => z.name === zoneName);
+  return zone?.id ?? null;
+}
+async function generateCloudflareEmailRoutingToken(input) {
+  const fetchImpl = input.fetchImpl ?? fetch;
+  const zoneId = await findCloudflareZoneIdByName(
+    input.accessToken,
+    input.zoneName,
+    fetchImpl
+  );
+  if (!zoneId) {
+    throw new Error(`Cloudflare zone "${input.zoneName}" not found`);
+  }
+  const groups = await listCloudflarePermissionGroups(
+    input.accessToken,
+    fetchImpl
+  );
+  const emailRoutingGroup = groups.find(
+    (g) => g.name.toLowerCase().includes("email routing")
+  );
+  if (!emailRoutingGroup) {
+    throw new Error(
+      "Cloudflare Email Routing Edit permission group not found for this account."
+    );
+  }
+  const token = await createCloudflareApiToken({
+    name: input.tokenName ?? `nolo-email-routing-${input.zoneName}-${Date.now()}`,
+    policies: [buildEmailRoutingPolicy(zoneId, [emailRoutingGroup.id])],
+    accessToken: input.accessToken,
+    fetchImpl
+  });
+  return { token, zoneId };
+}
+function buildEmailRoutingPolicy(zoneId, emailRoutingPermissionGroupIds) {
+  if (emailRoutingPermissionGroupIds.length === 0) {
+    throw new Error(
+      "Email routing permission group IDs are required. Resolve them with listCloudflarePermissionGroups."
+    );
+  }
+  return {
+    effect: "allow",
+    resources: {
+      "com.cloudflare.api.account": "*",
+      "com.cloudflare.api.zone": zoneId
+    },
+    permission_groups: emailRoutingPermissionGroupIds.map((id) => ({ id }))
+  };
+}
+
+// packages/cli/oauth/envFile.ts
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+function upsertEnvVariable(filePath, key, value) {
+  const normalizedPath = resolve(filePath);
+  let content = "";
+  if (existsSync(normalizedPath)) {
+    content = readFileSync(normalizedPath, "utf8");
+  }
+  const lines = content.length > 0 ? content.split("\n") : [];
+  const keyPrefix = `${key}=`;
+  let replaced = false;
+  const newLines = lines.map((line) => {
+    const trimmed = line.trim();
+    if (trimmed.startsWith(keyPrefix) || trimmed.startsWith(`${key} =`)) {
+      replaced = true;
+      return `${key}=${value}`;
+    }
+    return line;
+  });
+  if (!replaced) {
+    if (newLines.length > 0 && newLines[newLines.length - 1] !== "") {
+      newLines.push("");
+    }
+    newLines.push(`${key}=${value}`);
+  }
+  writeFileSync(normalizedPath, newLines.join("\n"), "utf8");
+}
+function parseFlagWithOptionalValue(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return void 0;
+  const next = args[index + 1];
+  if (next && !next.startsWith("--")) {
+    return next;
+  }
+  return true;
+}
+
+export {
+  runCloudflareOAuthLogin,
+  generateCloudflareEmailRoutingToken,
+  upsertEnvVariable,
+  parseFlagWithOptionalValue
+};