nolo-cli 0.8.0-alpha.6 → 0.8.0-alpha.7

package/chunk-ISNCLGUZ.js

@@ -0,0 +1,146 @@
+import {
+  DEFAULT_NOLO_SERVER_URL
+} from "./chunk-OLZBQWZU.js";
+import {
+  DEFAULT_LOCAL_API_ORIGIN
+} from "./chunk-4SN6J65J.js";
+import {
+  NOLO_CLUSTER_SERVERS
+} from "./chunk-LCBAMY2M.js";
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+
+// packages/cli/cliEnvHelpers.ts
+import { dirname, extname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function resolveServerUrlFromEnv(env) {
+  return normalizeServerOrigin(
+    env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL
+  );
+}
+function isCliArgs(value) {
+  return Array.isArray(value);
+}
+function buildServerCandidates(values) {
+  return [...new Set(
+    values.filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => normalizeServerOrigin(value))
+  )];
+}
+function resolveServerUrl(input, env) {
+  if (isCliArgs(input)) {
+    const explicit = readOption(input, "--server-url") || readOption(input, "--server");
+    return normalizeServerOrigin(explicit) || resolveServerUrlFromEnv(env ?? {});
+  }
+  return resolveServerUrlFromEnv(input);
+}
+function resolveServerCandidates(input, envOrPreferred, preferred) {
+  if (isCliArgs(input)) {
+    const env2 = envOrPreferred ?? {};
+    const explicitServer = resolveServerUrl(input, env2);
+    return buildServerCandidates([
+      explicitServer,
+      preferred?.trim(),
+      env2.NOLO_SERVER,
+      env2.BASE_URL,
+      env2.NOLO_SERVER_URL,
+      DEFAULT_NOLO_SERVER_URL,
+      ...NOLO_CLUSTER_SERVERS
+    ]);
+  }
+  const env = input;
+  return buildServerCandidates([
+    asOptionalTrimmedString(envOrPreferred),
+    env.NOLO_SERVER,
+    env.BASE_URL,
+    env.NOLO_SERVER_URL,
+    DEFAULT_NOLO_SERVER_URL,
+    ...NOLO_CLUSTER_SERVERS
+  ]);
+}
+function resolveDeleteServerCandidatesFromEnv(env, ...preferredValues) {
+  return buildServerCandidates([
+    ...preferredValues,
+    env.NOLO_SERVER,
+    env.BASE_URL,
+    env.NOLO_SERVER_URL,
+    env.READ_DIALOG_BASE,
+    DEFAULT_NOLO_SERVER_URL,
+    ...NOLO_CLUSTER_SERVERS,
+    DEFAULT_LOCAL_API_ORIGIN
+  ]);
+}
+function resolveDeleteServerCandidates(input, envOrPreferred, preferred) {
+  if (isCliArgs(input)) {
+    const env2 = envOrPreferred ?? {};
+    const explicitServer = resolveServerUrl(input, env2);
+    return resolveDeleteServerCandidatesFromEnv(env2, explicitServer, preferred?.trim());
+  }
+  const env = input;
+  return resolveDeleteServerCandidatesFromEnv(
+    env,
+    asOptionalTrimmedString(envOrPreferred)
+  );
+}
+function resolveAuthTokenFromEnv(env, extraEnvKeys = []) {
+  for (const key of ["AUTH_TOKEN", "AUTH", ...extraEnvKeys]) {
+    const value = env[key];
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return "";
+}
+function resolveAuthToken(input, envOrExtraEnvKeys, extraEnvKeys = []) {
+  if (isCliArgs(input)) {
+    const env = envOrExtraEnvKeys ?? {};
+    return readOption(input, "--token") || readOption(input, "--machine-key") || resolveAuthTokenFromEnv(env, extraEnvKeys);
+  }
+  return resolveAuthTokenFromEnv(input, envOrExtraEnvKeys ?? []);
+}
+function parseUserIdFromAuthToken(token) {
+  const parts = token.trim().split(".").filter(Boolean);
+  const payloadCandidates = parts.length >= 3 ? [parts[1], parts[0]] : [parts[0]];
+  for (const payload of payloadCandidates) {
+    if (!payload) continue;
+    try {
+      const parsed = JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
+      if (typeof parsed?.userId === "string") return parsed.userId;
+    } catch {
+    }
+  }
+  return "";
+}
+function readOption(args, flag) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : void 0;
+}
+function isCompiledBinary() {
+  try {
+    const url = import.meta.url;
+    return url.startsWith("file:///$bunfs/root/") || url.startsWith("/$bunfs/root/");
+  } catch {
+    return false;
+  }
+}
+function resolveCliEntrypointPath(fromModuleUrl = import.meta.url) {
+  if (isCompiledBinary()) {
+    return process.execPath;
+  }
+  const sourcePath = fileURLToPath(fromModuleUrl);
+  const ext = extname(sourcePath) || ".ts";
+  return join(dirname(sourcePath), "..", `index${ext}`);
+}
+
+export {
+  resolveServerUrl,
+  resolveServerCandidates,
+  resolveDeleteServerCandidates,
+  resolveAuthTokenFromEnv,
+  resolveAuthToken,
+  parseUserIdFromAuthToken,
+  readOption,
+  isCompiledBinary,
+  resolveCliEntrypointPath
+};

package/chunk-IYQV26RA.js

@@ -0,0 +1,138 @@
+import {
+  selectCurrentServer
+} from "./chunk-VEJLAVTC.js";
+import {
+  patch
+} from "./chunk-G5H7RNFL.js";
+import {
+  selectIdentityToken
+} from "./chunk-EYEEHCU4.js";
+import {
+  getIsDesktopApp
+} from "./chunk-QYXLLLGL.js";
+
+// packages/ai/agent/cliChatClient.ts
+function getCliChatRequestConfig(thunkApi) {
+  const state = thunkApi.getState();
+  const currentServer = selectCurrentServer(state);
+  const token = selectIdentityToken(state);
+  if (!currentServer) throw new Error("\u65E0\u6CD5\u83B7\u53D6\u5F53\u524D\u670D\u52A1\u5668\u5730\u5740\u3002");
+  return { currentServer, token };
+}
+function resolveCliChatUrl(currentServer) {
+  if (getIsDesktopApp()) return "/api/cli/chat";
+  return `${currentServer}/api/cli/chat`;
+}
+async function postCliChat(thunkApi, body, signal) {
+  const { currentServer, token } = getCliChatRequestConfig(thunkApi);
+  return fetch(resolveCliChatUrl(currentServer), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...token ? { Authorization: `Bearer ${token}` } : {}
+    },
+    body: JSON.stringify(body),
+    signal
+  });
+}
+async function startCliChatSession(thunkApi, args) {
+  const response = await postCliChat(thunkApi, {
+    action: "start",
+    cliProvider: args.cliProvider,
+    model: args.model,
+    systemPrompt: args.systemPrompt,
+    reasoningEffort: args.reasoningEffort,
+    temperature: args.temperature,
+    topP: args.topP,
+    frequencyPenalty: args.frequencyPenalty,
+    presencePenalty: args.presencePenalty,
+    maxTokens: args.maxTokens,
+    enableThinking: args.enableThinking,
+    thinkingBudget: args.thinkingBudget
+  });
+  return response.json();
+}
+async function getCliChatSession(thunkApi, args) {
+  const response = await postCliChat(thunkApi, {
+    action: "get",
+    sessionId: args.sessionId
+  });
+  return response.json();
+}
+async function closeCliChatSession(thunkApi, args) {
+  const response = await postCliChat(thunkApi, {
+    action: "close",
+    sessionId: args.sessionId
+  });
+  return response.json();
+}
+function createCliChatTurnStream(thunkApi, args, signal) {
+  return postCliChat(
+    thunkApi,
+    args.sessionId ? {
+      action: "turn",
+      sessionId: args.sessionId,
+      prompt: args.prompt,
+      model: args.model,
+      reasoningEffort: args.reasoningEffort,
+      temperature: args.temperature,
+      topP: args.topP,
+      frequencyPenalty: args.frequencyPenalty,
+      presencePenalty: args.presencePenalty,
+      maxTokens: args.maxTokens,
+      enableThinking: args.enableThinking,
+      thinkingBudget: args.thinkingBudget
+    } : {
+      prompt: args.prompt,
+      model: args.model,
+      cliProvider: args.cliProvider,
+      systemPrompt: args.systemPrompt,
+      reasoningEffort: args.reasoningEffort,
+      temperature: args.temperature,
+      topP: args.topP,
+      frequencyPenalty: args.frequencyPenalty,
+      presencePenalty: args.presencePenalty,
+      maxTokens: args.maxTokens,
+      enableThinking: args.enableThinking,
+      thinkingBudget: args.thinkingBudget
+    },
+    signal
+  );
+}
+
+// packages/chat/dialog/actions/cleanupCliSession.ts
+async function cleanupCliSessionForDialog(thunkApi, dialogConfig) {
+  const cliSessionId = dialogConfig?.cliSessionId;
+  const dialogKey = dialogConfig?.dbKey;
+  if (!cliSessionId || !dialogKey) return;
+  try {
+    await closeCliChatSession(
+      { getState: thunkApi.getState },
+      { sessionId: cliSessionId }
+    );
+  } catch {
+  }
+  try {
+    const patchResult = thunkApi.dispatch(
+      patch({
+        dbKey: dialogKey,
+        changes: {
+          cliSessionId: null
+        }
+      })
+    );
+    if (typeof patchResult?.unwrap === "function") {
+      await patchResult.unwrap();
+    } else {
+      await patchResult;
+    }
+  } catch {
+  }
+}
+
+export {
+  startCliChatSession,
+  getCliChatSession,
+  createCliChatTurnStream,
+  cleanupCliSessionForDialog
+};

package/chunk-JBTJAPUF.js

@@ -0,0 +1,35 @@
+// packages/connector-experimental/codexBinary.ts
+import { copyFileSync, existsSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var WINDOWS_APPS_CODEX_PATTERN = /\\WindowsApps\\OpenAI\.Codex_[^\\]+\\app\\resources$/i;
+function pathEntries(env) {
+  return (env.PATH ?? process.env.PATH ?? "").split(process.platform === "win32" ? ";" : ":");
+}
+function findWindowsAppsCodex(env) {
+  if (process.platform !== "win32") return "";
+  for (const entry of pathEntries(env)) {
+    if (!WINDOWS_APPS_CODEX_PATTERN.test(entry)) continue;
+    const candidate = join(entry, "codex.exe");
+    if (existsSync(candidate)) return candidate;
+  }
+  return "";
+}
+function copyCodexToUserBin(source, env) {
+  const target = env.NOLO_CODEX_SHIM_PATH ?? join(homedir(), ".nolo", "bin", "codex.exe");
+  if (existsSync(target)) return target;
+  mkdirSync(dirname(target), { recursive: true });
+  copyFileSync(source, target);
+  return target;
+}
+function resolveLaunchableCodexCommand(env = process.env) {
+  const explicit = env.NOLO_CODEX_BIN?.trim();
+  if (explicit) return explicit;
+  const windowsAppsCodex = findWindowsAppsCodex(env);
+  if (windowsAppsCodex) return copyCodexToUserBin(windowsAppsCodex, env);
+  return "codex";
+}
+
+export {
+  resolveLaunchableCodexCommand
+};

package/chunk-JZPBVBIY.js

@@ -0,0 +1,94 @@
+// packages/agent-runtime/oauthTokenStore.ts
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var DEFAULT_REFRESH_SKEW_MS = 5 * 60 * 1e3;
+function getCredentialsDir(homeDir = homedir()) {
+  return join(homeDir, ".nolo", "credentials");
+}
+function getCredentialPath(provider, homeDir = homedir()) {
+  return join(getCredentialsDir(homeDir), `${provider}.json`);
+}
+function ensurePrivateDir(dir) {
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  try {
+    chmodSync(dir, 448);
+  } catch {
+  }
+}
+function writePrivateFile(path, body) {
+  writeFileSync(path, body, { encoding: "utf8", mode: 384 });
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+}
+function readOAuthCredential(provider, homeDir = homedir()) {
+  const path = getCredentialPath(provider, homeDir);
+  if (!existsSync(path)) return null;
+  const raw = readFileSync(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 = homedir()) {
+  const path = getCredentialPath(provider, homeDir);
+  ensurePrivateDir(getCredentialsDir(homeDir));
+  writePrivateFile(path, `${JSON.stringify(credential, null, 2)}
+`);
+}
+function removeOAuthCredential(provider, homeDir = homedir()) {
+  const path = getCredentialPath(provider, homeDir);
+  if (!existsSync(path)) return;
+  unlinkSync(path);
+}
+function createOAuthTokenStore(homeDir = homedir()) {
+  return {
+    read(provider) {
+      return readOAuthCredential(provider, homeDir);
+    },
+    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);
+  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 {
+  getCredentialsDir,
+  readOAuthCredential,
+  writeOAuthCredential,
+  createOAuthTokenStore,
+  isTokenExpired,
+  resolveFreshAccessToken
+};