nolo-cli 0.6.1 → 0.8.0-alpha.10

package/chunk-OF5H3QWS.js

@@ -0,0 +1,300 @@
+import {
+  buildCliRuntimeEnv,
+  clearProfileAuthToken,
+  getCurrentProfile,
+  getDefaultProfileConfigPath,
+  loadProfileConfig,
+  saveDefaultProfile
+} from "./chunk-ROWQEJRP.js";
+import {
+  resolveAuthTokenFromEnv
+} from "./chunk-ISNCLGUZ.js";
+import {
+  DEFAULT_NOLO_SERVER_URL
+} from "./chunk-OLZBQWZU.js";
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
+
+// packages/cli/authCommands.ts
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { spawn } from "node:child_process";
+var LOGIN_HELP_TEXT = `Log in to Nolo and save a local profile.
+
+Usage:
+  nolo login [--server <url>] [--no-browser] [--token <jwt>] [--manual]
+
+Options:
+  --server <url>   Nolo server URL (default: ${DEFAULT_NOLO_SERVER_URL})
+  --no-browser     Print the authorization URL instead of opening a browser
+  --token <jwt>    Save a token directly without browser authorization
+  --manual         Prompt to paste a token interactively
+
+By default, opens the Nolo website and polls until authorization completes.
+In SSH sessions, use --no-browser and open the printed URL on a machine with a browser
+where you are already logged into Nolo.
+
+Note: nolo login only authorizes your Nolo platform account. To let your agents
+call third-party models using your own subscriptions, you also need:
+  nolo auth antigravity   # Google Antigravity (Gemini 3, Claude, GPT-OSS)
+  nolo auth claude        # Claude Pro/Max
+  nolo auth chatgpt       # ChatGPT Plus / OpenAI Codex
+  nolo auth xai           # xAI Grok (SuperGrok)
+  nolo auth cloudflare    # Cloudflare OAuth (email routing, etc.)
+See "nolo auth <provider> --help" for details.
+`;
+var LOGOUT_HELP_TEXT = `Log out of Nolo by clearing the saved auth token.
+
+Usage:
+  nolo logout
+
+Keeps other profile settings such as server URL and default agent preferences.
+Does not unset AUTH_TOKEN or other auth-related environment variables.
+`;
+var WHOAMI_HELP_TEXT = `Show the current login state.
+
+Usage:
+  nolo whoami
+`;
+function wantsHelp(args) {
+  return args.includes("--help") || args.includes("-h");
+}
+function formatDuration(ms) {
+  const totalSec = Math.max(0, Math.ceil(ms / 1e3));
+  const minutes = Math.floor(totalSec / 60);
+  const seconds = totalSec % 60;
+  if (minutes > 0) return `${minutes}m ${seconds}s`;
+  return `${seconds}s`;
+}
+function formatTokenPreview(token) {
+  const trimmed = token.trim();
+  if (!trimmed) return "";
+  return `${trimmed.slice(0, 8)}...`;
+}
+function getArg(args, flag) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : void 0;
+}
+var postJson = async (fetchImpl, url, body) => fetchImpl(url, {
+  method: "POST",
+  headers: { "Content-Type": "application/json" },
+  body: JSON.stringify(body)
+});
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var defaultOpenBrowser = async (url) => {
+  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url.replace(/&/g, "^&")] : [url];
+  try {
+    const child = spawn(command, args, {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+};
+async function saveTokenLogin(args) {
+  if (!args.authToken.trim()) {
+    args.error.error("No auth token provided.");
+    return 1;
+  }
+  saveDefaultProfile(args.configPath, {
+    serverUrl: args.serverUrl,
+    authToken: args.authToken.trim()
+  });
+  args.output.log(`Saved profile default -> ${args.serverUrl}`);
+  return 0;
+}
+async function runWebLogin(args) {
+  const startResponse = await postJson(
+    args.fetchImpl,
+    `${args.serverUrl}/api/v1/users/cli-login/start`,
+    { clientName: "nolo-cli" }
+  );
+  const start = await startResponse.json().catch(() => ({}));
+  if (!startResponse.ok || !start?.deviceCode || !start?.verificationUriComplete) {
+    args.error.error(
+      `Failed to start web login (${startResponse.status}). Use --token to paste a token manually.`
+    );
+    return 1;
+  }
+  args.output.log("Open this URL to authorize nolo-cli:");
+  args.output.log(start.verificationUriComplete);
+  args.output.log(`Code: ${start.userCode}`);
+  if (!args.noBrowser) {
+    const opened = await args.openBrowser(start.verificationUriComplete);
+    if (!opened) {
+      args.output.log("Could not open a browser automatically. Paste the URL above.");
+    }
+  }
+  const intervalMs = Math.max(1, Number(start.interval) || 2) * 1e3;
+  const timeoutMs = Math.max(1, Number(start.expiresIn) || 600) * 1e3;
+  const deadline = args.now() + timeoutMs;
+  const statusLogIntervalMs = 15e3;
+  let lastStatusLogAt = 0;
+  args.output.log(
+    `[nolo] Waiting for browser authorization (${formatDuration(timeoutMs)} remaining)...`
+  );
+  while (args.now() <= deadline) {
+    const pollResponse = await postJson(
+      args.fetchImpl,
+      `${args.serverUrl}/api/v1/users/cli-login/poll`,
+      { deviceCode: start.deviceCode }
+    );
+    const poll = await pollResponse.json().catch(() => ({}));
+    if (pollResponse.status === 202) {
+      const currentTime = args.now();
+      if (lastStatusLogAt > 0 && currentTime - lastStatusLogAt >= statusLogIntervalMs) {
+        const remainingMs = Math.max(0, deadline - currentTime);
+        args.output.log(
+          `[nolo] Still waiting... (${formatDuration(remainingMs)} remaining)`
+        );
+        lastStatusLogAt = currentTime;
+      } else if (lastStatusLogAt === 0) {
+        lastStatusLogAt = currentTime;
+      }
+      await args.sleep(intervalMs);
+      continue;
+    }
+    if (pollResponse.ok && poll?.token) {
+      const approvedServer = typeof poll.serverUrl === "string" && poll.serverUrl.trim() ? normalizeServerOrigin(poll.serverUrl) : args.serverUrl;
+      return saveTokenLogin({
+        configPath: args.configPath,
+        serverUrl: approvedServer,
+        authToken: poll.token,
+        output: args.output,
+        error: args.error
+      });
+    }
+    args.error.error(
+      `Web login failed: ${poll?.error || `HTTP ${pollResponse.status}`}. Use --token to paste a token manually.`
+    );
+    return 1;
+  }
+  args.error.error("Web login timed out. Run `nolo login` again or use --token.");
+  return 1;
+}
+async function runLoginCommand(args, deps = {}) {
+  const outputTarget = deps.output ?? console;
+  const errorTarget = deps.error ?? console;
+  if (wantsHelp(args)) {
+    outputTarget.log(LOGIN_HELP_TEXT);
+    return 0;
+  }
+  const configPath = deps.configPath ?? getDefaultProfileConfigPath();
+  const serverArg = getArg(args, "--server");
+  const tokenArg = getArg(args, "--token");
+  const noBrowser = args.includes("--no-browser");
+  const serverUrl = (serverArg || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
+  if (tokenArg) {
+    return saveTokenLogin({
+      configPath,
+      serverUrl,
+      authToken: tokenArg,
+      output: outputTarget,
+      error: errorTarget
+    });
+  }
+  if (args.includes("--manual")) {
+    const rl = createInterface({ input, output });
+    const question = deps.question ?? ((prompt) => rl.question(prompt));
+    try {
+      const authToken = await question("paste auth token: ");
+      return saveTokenLogin({
+        configPath,
+        serverUrl,
+        authToken,
+        output: outputTarget,
+        error: errorTarget
+      });
+    } finally {
+      rl.close();
+    }
+  }
+  return runWebLogin({
+    configPath,
+    serverUrl,
+    fetchImpl: deps.fetchImpl ?? fetch,
+    openBrowser: deps.openBrowser ?? defaultOpenBrowser,
+    sleep: deps.sleep ?? defaultSleep,
+    now: deps.now ?? Date.now,
+    output: outputTarget,
+    error: errorTarget,
+    noBrowser
+  });
+}
+function runWhoamiCommand(deps = {}) {
+  const output2 = deps.output ?? console;
+  if (wantsHelp(deps.args ?? [])) {
+    output2.log(WHOAMI_HELP_TEXT);
+    return 0;
+  }
+  const env = deps.env ?? process.env;
+  const config = loadProfileConfig(deps.configPath);
+  const profile = getCurrentProfile(config);
+  const profileToken = profile?.authToken?.trim() ?? "";
+  const envToken = resolveAuthTokenFromEnv(env);
+  if (!profileToken && !envToken) {
+    output2.log("Not logged in. Run: nolo login");
+    return 1;
+  }
+  const runtimeEnv = buildCliRuntimeEnv(env, config);
+  const explicitServer = env.NOLO_SERVER || env.NOLO_SERVER_URL || env.BASE_URL;
+  if (!profileToken && envToken) {
+    output2.log("profile: not logged in (no saved token)");
+    if (profile?.serverUrl) {
+      output2.log(`profile server: ${profile.serverUrl}`);
+    }
+    output2.log(`effective server: ${runtimeEnv.NOLO_SERVER ?? resolveServerUrlFallback(profile)}`);
+    output2.log(`server source: ${explicitServer ? "env" : profile?.serverUrl ? "profile" : "default"}`);
+    output2.log(`env token: ${formatTokenPreview(envToken)} (source: environment)`);
+    return 0;
+  }
+  const effectiveServer = runtimeEnv.NOLO_SERVER ?? profile.serverUrl;
+  const effectiveToken = runtimeEnv.AUTH_TOKEN ?? profileToken;
+  output2.log(`profile: ${config.currentProfile}`);
+  output2.log(`profile server: ${profile.serverUrl}`);
+  output2.log(`effective server: ${effectiveServer}`);
+  output2.log(`server source: ${explicitServer ? "env" : "profile"}`);
+  output2.log(`token: ${formatTokenPreview(effectiveToken)} (source: ${envToken && envToken !== profileToken ? "environment" : "profile"})`);
+  if (envToken && envToken !== profileToken) {
+    output2.log(`profile token: ${formatTokenPreview(profileToken)} (source: profile, overridden by environment)`);
+  }
+  return 0;
+}
+function resolveServerUrlFallback(profile) {
+  return profile?.serverUrl ?? DEFAULT_NOLO_SERVER_URL;
+}
+function runLogoutCommand(deps = {}) {
+  const output2 = deps.output ?? console;
+  if (wantsHelp(deps.args ?? [])) {
+    output2.log(LOGOUT_HELP_TEXT);
+    return 0;
+  }
+  const env = deps.env ?? process.env;
+  const configPath = deps.configPath ?? getDefaultProfileConfigPath();
+  if (!clearProfileAuthToken(configPath)) {
+    output2.log("Not logged in.");
+    return 0;
+  }
+  output2.log("Logged out.");
+  if (resolveAuthTokenFromEnv(env)) {
+    output2.log(
+      "Note: AUTH_TOKEN in the environment is unchanged and may still authenticate commands."
+    );
+  }
+  return 0;
+}
+
+export {
+  LOGIN_HELP_TEXT,
+  LOGOUT_HELP_TEXT,
+  WHOAMI_HELP_TEXT,
+  defaultOpenBrowser,
+  runLoginCommand,
+  runWhoamiCommand,
+  runLogoutCommand
+};

package/chunk-OLZBQWZU.js

@@ -0,0 +1,6 @@
+// packages/cli/defaultServer.ts
+var DEFAULT_NOLO_SERVER_URL = "https://nolo.chat";
+
+export {
+  DEFAULT_NOLO_SERVER_URL
+};

package/chunk-OOYVBFM7.js

@@ -0,0 +1,191 @@
+import {
+  listUserRecordsFromServers,
+  readLiveDbRecordAfterTombstoneMerge
+} from "./chunk-QUWDTOUP.js";
+import {
+  agentRecordHasConfiguredCredential
+} from "./chunk-FQZWM5YX.js";
+
+// packages/cli/agentListHelpers.ts
+function parseAgentRecordId(privateKey, explicitId) {
+  if (explicitId) return explicitId;
+  const agentMatch = privateKey.match(/^agent-[^-]+-(.+)$/i);
+  return agentMatch?.[1] ?? "";
+}
+function buildCompanionKeys(rawId, userId) {
+  return {
+    privateKey: `agent-${userId}-${rawId}`,
+    publicKey: `agent-pub-${rawId}`
+  };
+}
+function normalizeListedAgent(record) {
+  const privateKey = typeof record?.dbKey === "string" ? record.dbKey : "";
+  const explicitId = typeof record?.id === "string" && record.id ? record.id : void 0;
+  const ownerUserId = typeof record?.userId === "string" ? record.userId : "";
+  const rawId = explicitId || (ownerUserId && privateKey.startsWith(`agent-${ownerUserId}-`) ? privateKey.slice(`agent-${ownerUserId}-`.length) : parseAgentRecordId(privateKey, explicitId));
+  if (!privateKey || !rawId || !ownerUserId) return null;
+  const keys = buildCompanionKeys(rawId, ownerUserId);
+  const credentialConfigured = agentRecordHasConfiguredCredential(record);
+  const credentialRef = typeof record?.credentialRef === "string" && record.credentialRef ? record.credentialRef : void 0;
+  const apiKeyRef = typeof record?.apiKeyRef === "string" && record.apiKeyRef ? record.apiKeyRef : void 0;
+  return {
+    id: rawId,
+    privateKey,
+    publicKey: keys.publicKey,
+    name: typeof record?.name === "string" && record.name ? record.name : "(unnamed)",
+    model: typeof record?.model === "string" && record.model ? record.model : "-",
+    updatedAt: typeof record?.updatedAt === "string" || typeof record?.updatedAt === "number" ? record.updatedAt : typeof record?.createdAt === "string" || typeof record?.createdAt === "number" ? record.createdAt : typeof record?.created === "string" || typeof record?.created === "number" ? record.created : null,
+    isPublicFlag: !!record?.isPublic,
+    publicRecordExists: false,
+    type: typeof record?.type === "string" ? record.type : null,
+    tools: Array.isArray(record?.tools) ? record.tools.filter((tool) => typeof tool === "string") : [],
+    credentialConfigured,
+    credentialRef,
+    apiKeyRef,
+    ...typeof record?.apiSource === "string" && record.apiSource ? { apiSource: record.apiSource } : {},
+    ...typeof record?.cliProvider === "string" && record.cliProvider ? { cliProvider: record.cliProvider } : {}
+  };
+}
+function sortListedAgents(agents) {
+  agents.sort((a, b) => {
+    const ta = a.updatedAt == null ? 0 : new Date(a.updatedAt).getTime();
+    const tb = b.updatedAt == null ? 0 : new Date(b.updatedAt).getTime();
+    return tb - ta;
+  });
+  return agents;
+}
+function parseAgentListArgs(args) {
+  return {
+    wantJson: args.includes("--json"),
+    publicOnly: args.includes("--public-only"),
+    idsOnly: args.includes("--ids-only")
+  };
+}
+async function listLocalCachedAgents(args) {
+  const privateRecords = /* @__PURE__ */ new Map();
+  const publicKeys = /* @__PURE__ */ new Set();
+  for await (const [key, value] of args.db.iterator({ gte: "", lte: "\uFFFF" })) {
+    if (typeof key !== "string" || !value || typeof value !== "object") continue;
+    if (key.startsWith(`agent-${args.userId}-`)) {
+      privateRecords.set(key, { ...value, dbKey: key });
+      continue;
+    }
+    if (key.startsWith("agent-pub-")) {
+      publicKeys.add(key);
+    }
+  }
+  const agents = sortListedAgents(
+    [...privateRecords.values()].map((record) => normalizeListedAgent(record)).filter((agent) => agent != null)
+  );
+  for (const agent of agents) {
+    agent.publicRecordExists = publicKeys.has(agent.publicKey);
+  }
+  return agents;
+}
+async function hasReadableRecord(args) {
+  try {
+    await args.readDbRecord(args);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listRemoteAgents(args) {
+  const recordGroups = [await args.queryUserRecords({ ...args, type: "agent" })];
+  const agents = sortListedAgents(
+    recordGroups.flat().map((record) => normalizeListedAgent(record)).filter((agent) => agent != null)
+  );
+  await Promise.all(
+    agents.map(async (agent) => {
+      agent.publicRecordExists = await hasReadableRecord({
+        authToken: args.authToken,
+        dbKey: agent.publicKey,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        serverUrl: args.serverUrl,
+        readDbRecord: args.readDbRecord
+      });
+    })
+  );
+  return agents;
+}
+async function listRemoteAgentsAcrossServers(args) {
+  const remoteResult = await listUserRecordsFromServers({
+    authToken: args.authToken,
+    fallbackFetchImpl: args.fallbackFetchImpl,
+    fetchImpl: args.fetchImpl,
+    label: "agent query",
+    serverUrls: args.serverUrls,
+    type: "agent",
+    userId: args.userId
+  });
+  const agents = sortListedAgents(
+    remoteResult.records.map((record) => normalizeListedAgent(record)).filter((agent) => agent != null)
+  );
+  return { agents, failures: remoteResult.failures };
+}
+async function listFavoriteAgentIdsAcrossServers(args) {
+  const favoritedAtByKey = {};
+  await Promise.all(
+    args.serverUrls.map(async (serverUrl) => {
+      try {
+        const res = await args.fetchImpl(`${serverUrl}/rpc/listFavorites`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${args.authToken}`
+          },
+          body: JSON.stringify({ targetType: "agent" })
+        });
+        if (!res.ok) return;
+        const data = await res.json().catch(() => ({}));
+        const items = Array.isArray(data?.items) ? data.items : [];
+        for (const item of items) {
+          const id = typeof item?.id === "string" ? item.id : "";
+          if (!id) continue;
+          const at = Number(item?.favoritedAt) || 0;
+          favoritedAtByKey[id] = Math.max(
+            favoritedAtByKey[id] ?? 0,
+            at || Date.now()
+          );
+        }
+        const ids = Array.isArray(data?.ids) ? data.ids : [];
+        for (const id of ids) {
+          if (typeof id === "string" && id && !(id in favoritedAtByKey)) {
+            favoritedAtByKey[id] = 1;
+          }
+        }
+      } catch {
+      }
+    })
+  );
+  return favoritedAtByKey;
+}
+async function decorateAgentsWithPublicStatusAcrossServers(args) {
+  await Promise.all(
+    args.agents.map(async (agent) => {
+      try {
+        const result = await readLiveDbRecordAfterTombstoneMerge({
+          authToken: args.authToken,
+          dbKey: agent.publicKey,
+          fallbackFetchImpl: args.fallbackFetchImpl,
+          fetchImpl: args.fetchImpl,
+          serverUrls: args.serverUrls
+        });
+        agent.publicRecordExists = result.record?.isPublic === true;
+      } catch {
+        agent.publicRecordExists = false;
+      }
+    })
+  );
+  return args.agents;
+}
+
+export {
+  parseAgentListArgs,
+  listLocalCachedAgents,
+  listRemoteAgents,
+  listRemoteAgentsAcrossServers,
+  listFavoriteAgentIdsAcrossServers,
+  decorateAgentsWithPublicStatusAcrossServers
+};

package/chunk-OWOHNGCN.js

@@ -0,0 +1,50 @@
+import {
+  compactWhitespace
+} from "./chunk-DWLEOOGR.js";
+
+// packages/chat/dialog/dialogTitle.ts
+var GENERATED_DIALOG_TITLE_MAX_CHARS = 36;
+var FALLBACK_DIALOG_TITLE_MAX_CHARS = 24;
+var WRAPPING_QUOTES_RE = /^[`"'“”‘’「」『』《》]+|[`"'“”‘’「」『』《》]+$/gu;
+var TRAILING_TITLE_PUNCTUATION_RE = /[。！？!?；;，,、：:]+$/u;
+var clip = (text, maxChars) => text.length <= maxChars ? text : `${text.slice(0, maxChars - 1).trimEnd()}\u2026`;
+var toSingleLine = (value) => value.replace(/\r\n?/g, "\n").split("\n").map((line) => line.trim()).find(Boolean) ?? "";
+var stripTitleFormatting = (value) => value.replace(/^(?:[-*#>]+\s*|\d+\.\s+)/, "").replace(WRAPPING_QUOTES_RE, "").replace(TRAILING_TITLE_PUNCTUATION_RE, "").trim();
+var pickLeadingClause = (value) => {
+  const firstLine = toSingleLine(value);
+  if (!firstLine) return "";
+  const separatorIndexes = [firstLine.indexOf("\uFF1A"), firstLine.indexOf(":")].filter((index) => index > 0).sort((left, right) => left - right);
+  for (const index of separatorIndexes) {
+    const clause = firstLine.slice(0, index).trim();
+    if (clause.length >= 4) return clause;
+  }
+  return firstLine;
+};
+var normalizeDialogTitle = (rawTitle, maxChars = GENERATED_DIALOG_TITLE_MAX_CHARS) => {
+  if (typeof rawTitle !== "string") return "";
+  const normalized = stripTitleFormatting(
+    compactWhitespace(toSingleLine(rawTitle))
+  );
+  if (!normalized) return "";
+  return clip(normalized, maxChars);
+};
+var buildDialogFallbackTitleFromUserInput = (userInput, maxChars = FALLBACK_DIALOG_TITLE_MAX_CHARS) => {
+  if (typeof userInput !== "string") return "";
+  const candidate = pickLeadingClause(userInput);
+  return normalizeDialogTitle(candidate || userInput, maxChars);
+};
+var buildDialogFallbackTitleFromMessages = (messages) => {
+  for (const message of messages) {
+    if (message?.role !== "user") continue;
+    const title = buildDialogFallbackTitleFromUserInput(message?.content);
+    if (title) return title;
+  }
+  return "";
+};
+var resolveDialogTitle = (generatedTitle, fallbackTitle) => normalizeDialogTitle(generatedTitle) || fallbackTitle.trim();
+
+export {
+  normalizeDialogTitle,
+  buildDialogFallbackTitleFromMessages,
+  resolveDialogTitle
+};