nolo-cli 0.54.0 → 0.61.0-alpha.2

package/{chunk-NFLA6GSU.js → chunk-MXUDQZXQ.js}

@@ -11,10 +11,10 @@ import {
   getAntigravityUserAgent,
   normalizeAntigravityTokenPayload,
   refreshAntigravityToken
-} from "./chunk-BG7J6Y5X.js";
+} from "./chunk-QEW2MFDQ.js";
 import {
   writeOAuthCredential
-} from "./chunk-FD36SCCD.js";
+} from "./chunk-ONXOABJR.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
@@ -483,6 +483,39 @@ async function refreshOpenAiCodexToken(credential, deps = {}) {
   });
 }
 
+// packages/cli/oauth/deviceCodeDisplay.ts
+var BOLD = "\x1B[1m";
+var RESET = "\x1B[0m";
+function renderDeviceCodeDisplay(args) {
+  const { provider, verificationUrl, completeUrl, userCode, notes = [] } = args;
+  const bold = args.isTTY ?? Boolean(process.stdout.isTTY);
+  const rows = [
+    { rendered: `  URL:  ${verificationUrl}  `, plain: `  URL:  ${verificationUrl}  ` }
+  ];
+  if (completeUrl) {
+    rows.push({
+      rendered: `  Link: ${completeUrl}  `,
+      plain: `  Link: ${completeUrl}  `
+    });
+  }
+  rows.push({
+    rendered: `  Code: ${bold ? `${BOLD}${userCode}${RESET}` : userCode}  `,
+    plain: `  Code: ${userCode}  `
+  });
+  const innerWidth = Math.max(...rows.map((row) => row.plain.length));
+  const top = `\u250C${"\u2500".repeat(innerWidth)}\u2510`;
+  const bottom = `\u2514${"\u2500".repeat(innerWidth)}\u2518`;
+  return [
+    `Authorize nolo-cli for ${provider} (device code / headless):`,
+    top,
+    ...rows.map(
+      (row) => `\u2502${row.rendered}${" ".repeat(innerWidth - row.plain.length)}\u2502`
+    ),
+    bottom,
+    ...notes
+  ];
+}
+
 // packages/cli/oauth/pkce.ts
 import { createHash, randomBytes } from "node:crypto";
 var PKCE_VERIFIER_LENGTH = 64;
@@ -612,9 +645,14 @@ async function pollDeviceCodeToken(args) {
 async function runOpenAiCodexDeviceCode(deps = {}) {
   const now = deps.now ?? Date.now;
   const start = await startDeviceCodeFlow(deps);
-  deps.output?.log?.("Authorize nolo-cli for ChatGPT / OpenAI Codex:");
-  deps.output?.log?.(OPENAI_CODEX_DEVICE_VERIFICATION_URL);
-  deps.output?.log?.(`Enter code: ${start.userCode}`);
+  for (const line of renderDeviceCodeDisplay({
+    provider: "ChatGPT / OpenAI Codex",
+    verificationUrl: OPENAI_CODEX_DEVICE_VERIFICATION_URL,
+    userCode: start.userCode,
+    notes: ["Code expires in ~15 minutes. Never share the code or tokens."]
+  })) {
+    deps.output?.log?.(line);
+  }
   if (deps.openBrowser) {
     const opened = await deps.openBrowser(OPENAI_CODEX_DEVICE_VERIFICATION_URL);
     if (!opened) deps.output?.log?.("Could not open a browser automatically. Open the URL above.");
@@ -1116,6 +1154,7 @@ export {
   startCallbackServer,
   runAntigravityOAuthLogin,
   refreshAntigravityOAuthToken,
+  renderDeviceCodeDisplay,
   generatePkcePair,
   runOpenAiCodexDeviceCode,
   runOpenAiCodexBrowserPkce,

package/chunk-N4G4PKQ6.js

@@ -0,0 +1,23 @@
+// packages/core/abortableDelay.ts
+function waitForAbortableDelay(ms, signal) {
+  const delayMs = Number.isFinite(ms) && ms >= 0 ? Math.round(ms) : 0;
+  if (signal?.aborted) {
+    return Promise.reject(new DOMException("Aborted", "AbortError"));
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timeoutId);
+      signal?.removeEventListener("abort", onAbort);
+      reject(new DOMException("Aborted", "AbortError"));
+    };
+    const timeoutId = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, delayMs);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+export {
+  waitForAbortableDelay
+};

package/{chunk-KXKQO4Q6.js → chunk-NTW5GWDM.js}

@@ -1,20 +1,76 @@
+import {
+  estimateTokenCount
+} from "./chunk-PSCNXBYA.js";
+
 // packages/ai/tools/agent/agentRunDisplayHelpers.ts
 function buildDelegatedTaskContent(task, input) {
   if (input === void 0 || input === null) {
     return task;
   }
   if (typeof input === "string") {
+    const trimmedInput = input.trim();
+    if (!trimmedInput || trimmedInput === task.trim()) {
+      return task;
+    }
     return `${task}
 
 --- INPUT (text) ---
 ${input}`;
   }
-  const jsonStr = JSON.stringify(input, null, 2);
+  let jsonStr;
+  try {
+    const serialized = JSON.stringify(input, null, 2);
+    if (serialized === void 0) {
+      return task;
+    }
+    jsonStr = serialized;
+  } catch {
+    jsonStr = "[Unserializable Input]";
+  }
   return `${task}
 
 --- INPUT (json) ---
 ${jsonStr}`;
 }
+function calculateDelegatedPayloadMetrics(task, input, delegatedContent) {
+  const taskText = typeof task === "string" ? task : "";
+  const taskChars = taskText.length;
+  let inputChars = 0;
+  let serializedInputForTokens = void 0;
+  if (input !== void 0 && input !== null) {
+    if (typeof input === "string") {
+      inputChars = input.length;
+      serializedInputForTokens = input;
+    } else {
+      try {
+        const serialized = JSON.stringify(input, null, 2);
+        if (serialized !== void 0) {
+          inputChars = serialized.length;
+          serializedInputForTokens = serialized;
+        } else {
+          inputChars = 0;
+        }
+      } catch {
+        const fallback = "[Unserializable Input]";
+        inputChars = fallback.length;
+        serializedInputForTokens = fallback;
+      }
+    }
+  }
+  const finalContent = delegatedContent ?? buildDelegatedTaskContent(task, input);
+  const totalChars = finalContent.length;
+  const estimatedTaskTokens = estimateTokenCount(taskText);
+  const estimatedTotalTokens = estimateTokenCount(finalContent);
+  const estimatedInputTokens = serializedInputForTokens && inputChars > 0 ? estimateTokenCount(serializedInputForTokens) : 0;
+  return {
+    taskChars,
+    inputChars,
+    totalChars,
+    estimatedTaskTokens,
+    estimatedInputTokens,
+    estimatedTotalTokens
+  };
+}
 function getAgentRunStatusIcon(status) {
   switch (status) {
     case "running":
@@ -221,6 +277,7 @@ function isAgentRunTerminalStatus(status) {
 
 export {
   buildDelegatedTaskContent,
+  calculateDelegatedPayloadMetrics,
   getAgentRunStatusIcon,
   shortRunId,
   clipText,

package/chunk-ONXOABJR.js

@@ -0,0 +1,215 @@
+// packages/agent-runtime/oauthTokenStore.ts
+import {
+  chmodSync as chmodSync2,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join3 } from "node:path";
+
+// packages/agent-runtime/credentialLocationMigration.ts
+import {
+  chmodSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  linkSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, join } from "node:path";
+function getLegacyCredentialPath(relativePath, legacyHomeDir) {
+  return join(legacyHomeDir, ".nolo", "credentials", relativePath);
+}
+function credentialMigrationMarkerPath(canonicalPath) {
+  return `${canonicalPath}.legacy-migration-complete`;
+}
+function isRegularFile(path) {
+  try {
+    return lstatSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function ensurePrivateDir(dir) {
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  try {
+    chmodSync(dir, 448);
+  } catch {
+  }
+}
+function markCredentialMigrationComplete(canonicalPath) {
+  const marker = credentialMigrationMarkerPath(canonicalPath);
+  ensurePrivateDir(dirname(marker));
+  if (existsSync(marker)) return;
+  writeFileSync(marker, "\n", { encoding: "utf8", mode: 384 });
+  try {
+    chmodSync(marker, 384);
+  } catch {
+  }
+}
+function migrateLegacyCredentialFile(args) {
+  if (args.mode !== "production" && args.mode !== "test") return false;
+  if (existsSync(credentialMigrationMarkerPath(args.canonicalPath))) return false;
+  if (existsSync(args.canonicalPath)) {
+    markCredentialMigrationComplete(args.canonicalPath);
+    return false;
+  }
+  if (!isRegularFile(args.legacyPath)) return false;
+  let raw;
+  try {
+    raw = readFileSync(args.legacyPath, "utf8");
+    if (!args.isValid(raw)) return false;
+  } catch {
+    return false;
+  }
+  ensurePrivateDir(dirname(args.canonicalPath));
+  const tempPath = `${args.canonicalPath}.migrate-${process.pid}-${Math.random().toString(36).slice(2)}`;
+  try {
+    writeFileSync(tempPath, raw, { encoding: "utf8", mode: 384 });
+    try {
+      chmodSync(tempPath, 384);
+    } catch {
+    }
+    try {
+      linkSync(tempPath, args.canonicalPath);
+    } catch {
+      unlinkSync(tempPath);
+      return false;
+    }
+    unlinkSync(tempPath);
+    markCredentialMigrationComplete(args.canonicalPath);
+    try {
+      chmodSync(args.canonicalPath, 384);
+    } catch {
+    }
+    return true;
+  } catch {
+    try {
+      unlinkSync(tempPath);
+    } catch {
+    }
+    return false;
+  }
+}
+
+// packages/agent-runtime/noloStateDir.ts
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+function resolveNoloStateDir(name, homeDir) {
+  if (homeDir) return join2(homeDir, ".nolo", name);
+  const noloHome = process.env.NOLO_HOME?.trim();
+  return noloHome ? join2(noloHome, name) : join2(homedir(), ".nolo", name);
+}
+
+// packages/agent-runtime/oauthTokenStore.ts
+var DEFAULT_REFRESH_SKEW_MS = 5 * 60 * 1e3;
+function getCredentialsDir(homeDir) {
+  return resolveNoloStateDir("credentials", homeDir);
+}
+function getCredentialPath(provider, homeDir) {
+  return join3(getCredentialsDir(homeDir), `${provider}.json`);
+}
+function ensurePrivateDir2(dir) {
+  mkdirSync2(dir, { recursive: true, mode: 448 });
+  try {
+    chmodSync2(dir, 448);
+  } catch {
+  }
+}
+function writePrivateFile(path, body) {
+  writeFileSync2(path, body, { encoding: "utf8", mode: 384 });
+  try {
+    chmodSync2(path, 384);
+  } catch {
+  }
+}
+function isValidOAuthCredential(raw, provider) {
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed?.provider === provider && typeof parsed.accessToken === "string" && Boolean(parsed.accessToken);
+  } catch {
+    return false;
+  }
+}
+function migrateOAuthCredentialIfNeeded(provider, homeDir, migration) {
+  if (homeDir !== void 0 || !migration?.enableLegacyMigration) return;
+  const legacyHomeDir = migration.legacyHomeDir ?? homedir2();
+  const canonicalPath = getCredentialPath(provider);
+  migrateLegacyCredentialFile({
+    canonicalPath,
+    legacyPath: getLegacyCredentialPath(`${provider}.json`, legacyHomeDir),
+    mode: migration.mode ?? (migration.legacyHomeDir ? "test" : "production"),
+    isValid: (raw) => isValidOAuthCredential(raw, provider)
+  });
+}
+function readOAuthCredential(provider, homeDir, migration) {
+  migrateOAuthCredentialIfNeeded(provider, homeDir, migration);
+  const path = getCredentialPath(provider, homeDir);
+  if (!existsSync2(path)) return null;
+  const raw = readFileSync2(path, "utf8");
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed?.provider || !parsed?.accessToken) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeOAuthCredential(provider, credential, homeDir) {
+  const path = getCredentialPath(provider, homeDir);
+  ensurePrivateDir2(getCredentialsDir(homeDir));
+  writePrivateFile(path, `${JSON.stringify(credential, null, 2)}
+`);
+}
+function removeOAuthCredential(provider, homeDir) {
+  const path = getCredentialPath(provider, homeDir);
+  if (!existsSync2(path)) return;
+  unlinkSync2(path);
+}
+function createOAuthTokenStore(homeDir, migration) {
+  return {
+    read(provider) {
+      return readOAuthCredential(provider, homeDir, migration);
+    },
+    write(provider, credential) {
+      writeOAuthCredential(provider, credential, homeDir);
+    },
+    remove(provider) {
+      removeOAuthCredential(provider, homeDir);
+    }
+  };
+}
+function isTokenExpired(credential, skewMs = DEFAULT_REFRESH_SKEW_MS, now = Date.now()) {
+  if (!credential.expiresAt) return false;
+  return credential.expiresAt - now <= skewMs;
+}
+async function resolveFreshAccessToken(args) {
+  const store = args.store ?? createOAuthTokenStore(args.homeDir, args.migration);
+  const now = args.now ?? Date.now;
+  const credential = store.read(args.provider);
+  if (!credential) return null;
+  if (!args.force && !isTokenExpired(credential, args.skewMs ?? DEFAULT_REFRESH_SKEW_MS, now())) {
+    return credential.accessToken;
+  }
+  if (!credential.refreshToken || !args.refresh) return null;
+  const refreshed = await args.refresh(credential);
+  store.write(args.provider, refreshed);
+  return refreshed.accessToken;
+}
+
+export {
+  resolveNoloStateDir,
+  getLegacyCredentialPath,
+  migrateLegacyCredentialFile,
+  getCredentialsDir,
+  readOAuthCredential,
+  writeOAuthCredential,
+  createOAuthTokenStore,
+  isTokenExpired,
+  resolveFreshAccessToken
+};

package/{chunk-TY3ADTX5.js → chunk-OZX2IPKM.js}

@@ -10,6 +10,9 @@ import {
 import {
   extractCustomId
 } from "./chunk-BJIRLHJR.js";
+import {
+  selectIdentityToken
+} from "./chunk-SEJ5OS6F.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";
@@ -31,7 +34,10 @@ var resolveDesktopSafeServer = (value) => {
   return isLocalServerUrl(value) ? MAIN_SERVER : value || MAIN_SERVER;
 };
 var selectCurrentServerFromState = (state) => resolveDesktopSafeServer(state?.settings?.currentServer);
-var selectCurrentTokenFromState = (state) => typeof state?.auth?.currentToken === "string" ? state.auth.currentToken : null;
+var selectCurrentTokenFromState = (state) => {
+  const token = selectIdentityToken(state);
+  return typeof token === "string" ? token : null;
+};
 var selectCurrentDialogKeyFromState = (_state) => getActiveDialogKey();
 var resolveToolBaseUrl = (currentServer) => {
   const _window = globalThis.window;
@@ -48,7 +54,6 @@ var DESKTOP_LOCAL_TOOL_PATHS = /* @__PURE__ */ new Set([
   "/api/apply-edit",
   "/api/apply-line-edits",
   "/api/code-search",
-  "/api/search-repo",
   "/api/desktop/files/roots",
   "/api/desktop/files/roots/request",
   "/api/desktop/files/list",

package/{chunk-Q4XZVZPN.js → chunk-P7OOB7QP.js}

@@ -2,7 +2,7 @@ import {
   deleteDbRecord,
   queryUserRecords,
   readDbRecord
-} from "./chunk-SYYUU7EV.js";
+} from "./chunk-FHAGENAS.js";
 import {
   mergeAndDedupUserData
 } from "./chunk-KQHGZWSV.js";

package/{chunk-XIJZOCSP.js → chunk-PEZJEQAO.js}

@@ -7,7 +7,7 @@ import {
   listUserRecordsFromServers,
   readDbRecordFromServers,
   readLiveDbRecordAfterTombstoneMerge
-} from "./chunk-Q4XZVZPN.js";
+} from "./chunk-P7OOB7QP.js";
 import {
   fetchWithTransientRetry
 } from "./chunk-5XTOKQLW.js";

package/{chunk-SWJGJMTW.js → chunk-PQDIDWGX.js}

@@ -1,7 +1,7 @@
 import {
   generatePkcePair,
   startCallbackServer
-} from "./chunk-NFLA6GSU.js";
+} from "./chunk-MXUDQZXQ.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";

package/chunk-PSCNXBYA.js

@@ -0,0 +1,11 @@
+// packages/ai/context/tokenUtils.ts
+var estimateTokenCount = (text) => {
+  if (!text) return 0;
+  const chineseChars = (text.match(/[\u4e00-\u9fa5\u3400-\u4dbf]/g) || []).length;
+  const otherChars = text.length - chineseChars;
+  return Math.ceil(chineseChars * 1.5 + otherChars * 0.25);
+};
+
+export {
+  estimateTokenCount
+};