nolo-cli 0.1.29 → 0.1.31

package/integrations/openai/models.ts

@@ -16,38 +16,38 @@ const scalePrice = (price: ModelPrice, multiplier: number): ModelPrice => ({
 });
 
 const GPT_5_4_STANDARD_PRICE: ModelPrice = {
-  input: 2.5,
-  output: 15,
-  inputCacheHit: 0.25,
+  input: 2.5 * 8,
+  output: 15 * 8,
+  inputCacheHit: 0.25 * 8,
 };
 
 const GPT_5_5_STANDARD_PRICE: ModelPrice = {
-  input: 5,
-  output: 30,
-  inputCacheHit: 0.5,
+  input: 5 * 8,
+  output: 30 * 8,
+  inputCacheHit: 0.5 * 8,
 };
 
 const GPT_5_4_LONG_CONTEXT_PRICE: ModelPrice = {
-  input: 5,
-  output: 22.5,
-  inputCacheHit: 0.5,
+  input: 5 * 8,
+  output: 22.5 * 8,
+  inputCacheHit: 0.5 * 8,
 };
 
 const GPT_5_5_LONG_CONTEXT_PRICE: ModelPrice = {
-  input: 10,
-  output: 45,
-  inputCacheHit: 1,
+  input: 10 * 8,
+  output: 45 * 8,
+  inputCacheHit: 1 * 8,
 };
 
 const GPT_5_4_PRO_STANDARD_PRICE: ModelPrice = {
-  input: 30,
-  output: 180,
+  input: 30 * 8,
+  output: 180 * 8,
   inputCacheHit: 0,
 };
 
 const GPT_5_4_PRO_LONG_CONTEXT_PRICE: ModelPrice = {
-  input: 60,
-  output: 270,
+  input: 60 * 8,
+  output: 270 * 8,
   inputCacheHit: 0,
 };
 
@@ -141,7 +141,7 @@ export const openAIModels: Model[] = [
     // OpenAI's current public pricing page does not list GPT Image 2 separately.
     // Reuse GPT Image 1.5 pricing as a conservative placeholder until official
     // GPT Image 2 pricing is published.
-    price: { input: 5, output: 10, inputCacheHit: 1.25 },
+    price: { input: 5 * 8, output: 10 * 8, inputCacheHit: 1.25 * 8 },
     pricePerImage: 0.04 * 8,
   },
   {
@@ -190,7 +190,7 @@ export const openAIModels: Model[] = [
     contextWindow: 400_000,
     maxOutputTokens: 128_000,
     supportsReasoningEffort: true,
-    price: { input: 0.75, output: 4.5, inputCacheHit: 0.075 },
+    price: { input: 0.75 * 8, output: 4.5 * 8, inputCacheHit: 0.075 * 8 },
   },
   {
     name: "gpt-5.4-nano",
@@ -200,7 +200,7 @@ export const openAIModels: Model[] = [
     contextWindow: 400_000,
     maxOutputTokens: 128_000,
     supportsReasoningEffort: true,
-    price: { input: 0.2, output: 1.25, inputCacheHit: 0.02 },
+    price: { input: 0.2 * 8, output: 1.25 * 8, inputCacheHit: 0.02 * 8 },
   },
   {
     name: "gpt-5.4-pro",
@@ -247,7 +247,7 @@ export const openAIModels: Model[] = [
     contextWindow: 400_000,
     maxOutputTokens: 128_000,
     supportsReasoningEffort: true,
-    price: { input: 12.5, output: 100, inputCacheHit: 1.25 },
+    price: { input: 1.25 * 8, output: 10 * 8, inputCacheHit: 0.125 * 8 },
   },
   {
     name: "gpt-5-mini",
@@ -256,7 +256,7 @@ export const openAIModels: Model[] = [
     contextWindow: 400_000,
     maxOutputTokens: 128_000,
     supportsReasoningEffort: true,
-    price: { input: 2.5, output: 20, inputCacheHit: 0.25 },
+    price: { input: 0.25 * 8, output: 2 * 8, inputCacheHit: 0.025 * 8 },
   },
   {
     name: "o3-pro",
@@ -266,6 +266,6 @@ export const openAIModels: Model[] = [
     maxOutputTokens: 100_000,
     supportsReasoningEffort: true,
     endpointKey: "responses",
-    price: { input: 200, output: 800, inputCacheHit: 0 },
+    price: { input: 20 * 8, output: 80 * 8, inputCacheHit: 0 },
   },
 ];

package/integrations/xai/models.ts

@@ -6,7 +6,7 @@ export const xaiModels: Model[] = [
     displayName: "Grok4 0709",
     hasVision: false,
     contextWindow: 131072,
-    price: { input: 3 * 10, output: 15 * 10 }, // 30分 / 150分 → 0.3$ / 1.5$
+    price: { input: 3 * 8, output: 15 * 8 }, // $3/$15 per MTok × 7
     fnCall: true,
     jsonOutput: true,
   },

package/localRuntimeDb.ts

@@ -20,9 +20,46 @@ export function buildCliLocalRuntimeDbEnv(env: EnvLike = process.env) {
   };
 }
 
+export function isCliLocalRuntimeDbLockError(error: unknown): boolean {
+  const queue: unknown[] = [error];
+  const seen = new Set<unknown>();
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current || seen.has(current)) continue;
+    seen.add(current);
+
+    const text = `${(current as any)?.code ?? ""} ${(current as any)?.message ?? current}`;
+    if (/LEVEL_LOCKED|Resource temporarily unavailable|\/LOCK|LOCK:|db locked|locked/i.test(text)) {
+      return true;
+    }
+
+    if ((current as any)?.cause) queue.push((current as any).cause);
+    if (Array.isArray((current as any)?.errors)) queue.push(...(current as any).errors);
+  }
+
+  return false;
+}
+
+export function formatCliLocalRuntimeDbOpenError(dbPath: string, error: unknown) {
+  if (!isCliLocalRuntimeDbLockError(error)) {
+    return error instanceof Error ? error : new Error(String(error));
+  }
+  return new Error(
+    `CLI local runtime DB is locked at ${dbPath}. Another nolo local runtime is already using it. ` +
+      "Stop the other local runtime, rerun without --local, or set NOLO_SERVER_DB_PATH to a different cache path.",
+    { cause: error instanceof Error ? error : undefined }
+  );
+}
+
 export async function getDefaultCliLocalRuntimeDb(): Promise<CliLocalRuntimeDb> {
-  process.env.NOLO_SERVER_DB_PATH = buildCliLocalRuntimeDbEnv(process.env).NOLO_SERVER_DB_PATH;
+  const dbPath = buildCliLocalRuntimeDbEnv(process.env).NOLO_SERVER_DB_PATH;
+  process.env.NOLO_SERVER_DB_PATH = dbPath;
   const { default: serverDb, ensureServerDbOpen } = await import("./database/server/db");
-  await ensureServerDbOpen();
+  try {
+    await ensureServerDbOpen();
+  } catch (error) {
+    throw formatCliLocalRuntimeDbOpenError(dbPath, error);
+  }
   return serverDb as CliLocalRuntimeDb;
 }

package/machineCommandPrompts.ts

@@ -3,6 +3,7 @@ import {
   resolveMachineRunPermissionPolicy,
   type MachineRunPermissionPolicy,
 } from "./ai/agent/machineRunPermissions";
+import { buildNoloReadOnlyBridgePrompt } from "./noloReadBridgePrompt";
 
 export function inferTaskRunRole(agentKey: string, agentConfig: any) {
   const haystack = [agentKey, agentConfig?.name, agentConfig?.prompt]
@@ -62,6 +63,7 @@ export function buildConnectorCliPrompt(
   const policy = permissionPolicy ?? resolveMachineRunPermissionPolicy(agentConfig);
   return [
     typeof agentConfig?.prompt === "string" ? agentConfig.prompt.trim() : "",
+    buildNoloReadOnlyBridgePrompt(),
     bridgeArgs
       ? buildTaskRunBridgePrompt({
           agentKey: bridgeArgs.agentKey,

package/machineCommands.ts

@@ -1,4 +1,5 @@
 import type { MachineHeartbeat } from "./connector-experimental/protocol";
+import { NOLO_CLUSTER_SERVERS, normalizeKnownServerOrigin } from "./database/config";
 import { detectMachineInfo } from "./connector-experimental/machineInfo";
 import {
   type HeartbeatLoopOptions,
@@ -42,6 +43,7 @@ export {
 type MachineCommandDeps = {
   env?: EnvLike;
   output?: OutputLike;
+  signal?: AbortSignal;
   cliEntrypointPath?: string;
   maxConnectorAttempts?: number;
   sleep?: (ms: number) => Promise<void>;
@@ -60,6 +62,100 @@ type MachineCommandDeps = {
 };
 
 const defaultSleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
+const MACHINE_TOKEN_PREFIX = "sk_machine_";
+
+async function sleepWithAbort(ms: number, sleep: (ms: number) => Promise<void>, signal?: AbortSignal) {
+  if (!signal) {
+    await sleep(ms);
+    return;
+  }
+  if (signal.aborted) return;
+  await Promise.race([
+    sleep(ms),
+    new Promise<void>((resolve) => {
+      signal.addEventListener("abort", () => resolve(), { once: true });
+    }),
+  ]);
+}
+
+function resolveConnectorReconnectDelayMs(env: EnvLike) {
+  const raw = Number(env.NOLO_CONNECT_RECONNECT_MS ?? "");
+  return Number.isFinite(raw) && raw >= 0 ? raw : 5_000;
+}
+
+function isMachineToken(token: string) {
+  return token.trim().startsWith(MACHINE_TOKEN_PREFIX);
+}
+
+function resolveClusterConnectServerUrls(serverUrl: string, authToken: string) {
+  const normalizedPrimary = normalizeKnownServerOrigin(serverUrl) ?? serverUrl.trim().replace(/\/+$/, "");
+  if (isMachineToken(authToken)) return [normalizedPrimary];
+  const normalizedCluster = NOLO_CLUSTER_SERVERS
+    .map((baseUrl) => normalizeKnownServerOrigin(baseUrl) ?? baseUrl)
+    .filter((value, index, list) => value && list.indexOf(value) === index);
+  if (!normalizedCluster.includes(normalizedPrimary)) return [normalizedPrimary];
+  return [normalizedPrimary, ...normalizedCluster.filter((baseUrl) => baseUrl !== normalizedPrimary)];
+}
+
+function linkAbortSignal(signal: AbortSignal | undefined, controller: AbortController) {
+  if (!signal) return;
+  if (signal.aborted) {
+    controller.abort();
+    return;
+  }
+  signal.addEventListener("abort", () => controller.abort(), { once: true });
+}
+
+async function sendMachineHeartbeat(args: {
+  serverUrl: string;
+  authToken: string;
+  fetchImpl: typeof fetch;
+  machine: MachineHeartbeat;
+}) {
+  const res = await args.fetchImpl(`${args.serverUrl}/api/machines/heartbeat`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${args.authToken}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(args.machine),
+  });
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`HTTP ${res.status}\n${text}`);
+  }
+}
+
+async function sendHeartbeatAcrossServers(args: {
+  serverUrls: string[];
+  authToken: string;
+  fetchImpl: typeof fetch;
+  machine: MachineHeartbeat;
+  output: OutputLike;
+}) {
+  let primaryError: Error | null = null;
+  for (const [index, serverUrl] of args.serverUrls.entries()) {
+    try {
+      await sendMachineHeartbeat({
+        serverUrl,
+        authToken: args.authToken,
+        fetchImpl: args.fetchImpl,
+        machine: args.machine,
+      });
+    } catch (error) {
+      const resolvedError = error instanceof Error ? error : new Error(String(error));
+      if (index === 0) {
+        primaryError = resolvedError;
+      } else {
+        args.output.write(
+          `[nolo] secondary connector registration failed for ${serverUrl}: ${resolvedError.message}\n`
+        );
+      }
+    }
+  }
+  if (primaryError) throw primaryError;
+}
 
 async function defaultExecuteCli(
   provider: string,
@@ -75,9 +171,9 @@ function detectLaunchableMachineInfo() {
 }
 
 export async function runMachineConnectCommand(
-  args: string[],
-  deps: MachineCommandDeps = {}
-) {
+  args: string[],
+  deps: MachineCommandDeps = {}
+) {
   const env = deps.env ?? process.env;
   const output = deps.output ?? process.stdout;
   const authToken = resolveConnectAuthToken(args, env);
@@ -85,29 +181,31 @@ export async function runMachineConnectCommand(
     writeAuthMissing(output);
     return 1;
   }
-
+
   const serverUrl = resolveConnectServerUrl(args, env);
+  const serverUrls = resolveClusterConnectServerUrls(serverUrl, authToken);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const machine = (deps.machineInfo ?? detectLaunchableMachineInfo)();
   const sendHeartbeat = async () => {
-    const res = await fetchImpl(`${serverUrl}/api/machines/heartbeat`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${authToken}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify(machine),
-    });
-
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`HTTP ${res.status}\n${text}`);
-    }
-  };
+    await sendHeartbeatAcrossServers({
+      serverUrls,
+      authToken,
+      fetchImpl,
+      machine,
+      output,
+    });
+  };
 
   if (hasFlag(args, "--daemon") || hasFlag(args, "--background")) {
     return runMachineDaemonCommand({
-      env,
+      env: {
+        ...env,
+        NOLO_SERVER: serverUrl,
+        NOLO_SERVER_URL: serverUrl,
+        BASE_URL: serverUrl,
+        AUTH_TOKEN: authToken,
+        NOLO_MACHINE_API_KEY: authToken,
+      },
       output,
       cliEntrypointPath: deps.cliEntrypointPath,
       validateWorkspaceLinks: deps.validateWorkspaceLinks,
@@ -123,49 +221,82 @@ export async function runMachineConnectCommand(
     const maxAttempts = deps.maxConnectorAttempts ?? Infinity;
     const sleep = deps.sleep ?? defaultSleep;
     const reconnectDelayMs = resolveConnectorReconnectDelayMs(env);
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-      const runtimeServerUrl =
-        env.NOLO_CONNECT_RUNTIME_SERVER_URL ||
-        env.NOLO_RUNTIME_SERVER_URL ||
-        serverUrl;
-      const exitCode = await runMachineWsSession({
-        env,
-        output,
-        machine,
-        sendHeartbeat,
-        runHeartbeatLoop: deps.runHeartbeatLoop ?? defaultRunHeartbeatLoop,
-        connectWebSocket: deps.connectWebSocket ?? defaultConnectWebSocket,
-        serverUrl,
-        authToken,
-        resolveConnectorWebSocketTarget: (options) =>
-          resolveConnectorWebSocketTarget({
-            ...options,
-            fetchImpl,
-          }),
-        onMessage: (message, send) =>
-          handleConnectorRunMessage(
-            message,
-            send,
-            deps.executeCli ?? defaultExecuteCli,
-            {
-              ...env,
-              NOLO_SERVER: runtimeServerUrl,
-              NOLO_SERVER_URL: runtimeServerUrl,
-              BASE_URL: runtimeServerUrl,
-              AUTH_TOKEN: authToken,
-              NOLO_MACHINE_API_KEY: authToken,
-            },
-            fetchImpl,
-            {
-              buildConnectorCliPrompt,
-            }
-          ),
-      });
-      if (attempt >= maxAttempts) return exitCode;
-      output.write(`[nolo] Connector websocket disconnected. Reconnecting in ${reconnectDelayMs}ms.\n`);
-      await sleep(reconnectDelayMs);
-    }
-    return 0;
+    const runServerSession = async (targetServerUrl: string, signal?: AbortSignal) => {
+      for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        if (signal?.aborted) {
+          return { serverUrl: targetServerUrl, exitCode: 0 };
+        }
+        const runtimeServerUrl =
+          env.NOLO_CONNECT_RUNTIME_SERVER_URL ||
+          env.NOLO_RUNTIME_SERVER_URL ||
+          targetServerUrl;
+        const exitCode = await runMachineWsSession({
+          env,
+          output,
+          signal,
+          machine,
+          sendHeartbeat: () =>
+            sendMachineHeartbeat({
+              serverUrl: targetServerUrl,
+              authToken,
+              fetchImpl,
+              machine,
+            }),
+          runHeartbeatLoop: deps.runHeartbeatLoop ?? defaultRunHeartbeatLoop,
+          connectWebSocket: deps.connectWebSocket ?? defaultConnectWebSocket,
+          serverUrl: targetServerUrl,
+          authToken,
+          resolveConnectorWebSocketTarget: (options) =>
+            resolveConnectorWebSocketTarget({
+              ...options,
+              fetchImpl,
+            }),
+          onMessage: (message, send) =>
+            handleConnectorRunMessage(
+              message,
+              send,
+              deps.executeCli ?? defaultExecuteCli,
+              {
+                ...env,
+                NOLO_SERVER: runtimeServerUrl,
+                NOLO_SERVER_URL: runtimeServerUrl,
+                BASE_URL: runtimeServerUrl,
+                AUTH_TOKEN: authToken,
+                NOLO_MACHINE_API_KEY: authToken,
+              },
+              fetchImpl,
+              {
+                buildConnectorCliPrompt,
+              }
+            ),
+        });
+        if (exitCode === 2) return { serverUrl: targetServerUrl, exitCode: 2 };
+        if (signal?.aborted) {
+          return { serverUrl: targetServerUrl, exitCode: 0 };
+        }
+        if (attempt >= maxAttempts) return { serverUrl: targetServerUrl, exitCode };
+        output.write(`[nolo] Connector websocket disconnected. Reconnecting in ${reconnectDelayMs}ms.\n`);
+        await sleepWithAbort(reconnectDelayMs, sleep, signal);
+      }
+      return { serverUrl: targetServerUrl, exitCode: 0 };
+    };
+
+    const sessionAbort = new AbortController();
+    linkAbortSignal(deps.signal, sessionAbort);
+
+    const sessionPromises = serverUrls.map(async (targetServerUrl, index) => {
+      const result = await runServerSession(targetServerUrl, sessionAbort.signal);
+      if (index > 0 && result.exitCode !== 0 && !sessionAbort.signal.aborted) {
+        output.write(
+          `[nolo] secondary connector registration failed for ${targetServerUrl}: exit ${result.exitCode}\n`
+        );
+      }
+      return result;
+    });
+    const results = await Promise.all(sessionPromises);
+    if (results.some((result) => result.exitCode === 0)) return 0;
+    if (results.some((result) => result.exitCode === 2)) return 1;
+    return results[0]?.exitCode ?? 1;
   }
 
   if (hasFlag(args, "--watch")) {

package/machineStatusCommands.ts

@@ -1,5 +1,5 @@
-import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
 import type { OutputLike } from "./cliIoTypes";
+import { resolveAuthToken, resolveServerUrl } from "./cliEnvHelpers";
 
 type EnvLike = Record<string, string | undefined>;
 
@@ -21,14 +21,6 @@ export type MachineStatusCommandDeps = {
   fetchImpl?: typeof fetch;
 };
 
-function resolveServerUrl(env: EnvLike) {
-  return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
-}
-
-function resolveAuthToken(env: EnvLike) {
-  return env.AUTH_TOKEN || env.AUTH || "";
-}
-
 function writeAuthMissing(output: OutputLike) {
   output.write(
     "[nolo] Machine commands require an auth token. Run `nolo login` or set AUTH_TOKEN.\n"
@@ -52,18 +44,18 @@ export function formatMachineStatus(machines: MachineSummary[]) {
 }
 
 export async function runMachineStatusCommand(
-  _args: string[],
+  args: string[],
   deps: MachineStatusCommandDeps = {}
 ) {
   const env = deps.env ?? process.env;
   const output = deps.output ?? process.stdout;
-  const authToken = resolveAuthToken(env);
+  const authToken = resolveAuthToken(args, env);
   if (!authToken) {
     writeAuthMissing(output);
     return 1;
   }
 
-  const serverUrl = resolveServerUrl(env);
+  const serverUrl = resolveServerUrl(args, env);
   const fetchImpl = deps.fetchImpl ?? fetch;
   let res: Response;
   try {