@linzumi/cli 0.0.52-beta → 0.0.53-beta

package/README.md

@@ -62,7 +62,7 @@ Install the CLI or run it with `npx`:
 ```bash
 npm install -g @linzumi/cli@latest
 npx -y @linzumi/cli@latest signup
-npx -y @linzumi/cli@0.0.52-beta --version
+npx -y @linzumi/cli@0.0.53-beta --version
 linzumi --version
 ```
 
@@ -79,6 +79,12 @@ For explicit runner roots, pass a comma-separated allowlist:
 linzumi start ~/code/my-app --allowed-cwd <paths>
 ```
 
+For non-production Linzumi servers, `connect` accepts either API URL flag:
+
+```bash
+linzumi connect --linzumi-url ws://127.0.0.1:4140 --workspace default --allow-port-forwarding-by-default
+```
+
 ## Agent-first launch path
 
 The fastest path is the `npx -y @linzumi/cli@latest signup` command

package/dist/index.js

@@ -10456,7 +10456,7 @@ function realpathOrResolved(pathValue) {
 }
 
 // src/version.ts
-var linzumiCliVersion = "0.0.52-beta";
+var linzumiCliVersion = "0.0.53-beta";
 var linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
 
 // src/runnerLock.ts
@@ -11240,13 +11240,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   const codex = await connectCodexAppServer(codexUrl);
   cleanup.actions.push(() => codex.close());
   const seq = { value: 0 };
-  const codexThreads = options.channelSession === undefined ? await discoverCodexThreads(codex, options.cwd).catch((error) => {
-    log("kandan.codex_threads_startup_discovery_failed", {
-      message: error instanceof Error ? error.message : String(error)
-    });
-    return [];
-  }) : [];
-  const discoveredCodexThreads = { value: codexThreads };
+  const discoveredCodexThreads = { value: [] };
   const runtimeDefaults = runnerRuntimeDefaults(options);
   const instancePayload = {
     instanceId,
@@ -11255,7 +11249,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     tuiLaunched: options.launchTui,
     cwd: options.cwd,
     hostname: runnerHost,
-    codexThreads,
+    codexThreads: discoveredCodexThreads.value,
     workspace: runnerWorkspaceSlug(options) ?? null,
     channel: options.channelSession?.channelSlug ?? null,
     model: runtimeDefaults.model ?? null,
@@ -11399,19 +11393,11 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       message: error instanceof Error ? error.message : String(error)
     });
   });
-  const refreshDiscoveredCodexThreads = () => discoverCodexThreads(codex, options.cwd).then((threads) => {
-    discoveredCodexThreads.value = threads;
-    return kandan.push(topic, "heartbeat", heartbeatPayload());
-  }).catch((error) => {
-    log("kandan.codex_threads_refresh_failed", {
-      message: error instanceof Error ? error.message : String(error)
-    });
-  });
   const heartbeatInterval = setInterval(() => {
-    channelSession === undefined ? refreshDiscoveredCodexThreads() : pushHeartbeat();
+    pushHeartbeat();
   }, 15000);
   cleanup.actions.push(() => clearInterval(heartbeatInterval));
-  kandan.onReconnect(() => (channelSession === undefined ? refreshDiscoveredCodexThreads() : pushHeartbeat()).then(() => {
+  kandan.onReconnect(() => pushHeartbeat().then(() => {
     return;
   }));
   pushHeartbeat();
@@ -11681,96 +11667,6 @@ async function closeCleanupStack(cleanup) {
   })();
   return cleanup.closePromise;
 }
-async function discoverCodexThreads(codex, _cwd) {
-  const rowsById = new Map;
-  const archivedModes = [false, true];
-  const sourcePasses = [
-    undefined,
-    [
-      "exec",
-      "appServer",
-      "subAgent",
-      "subAgentReview",
-      "subAgentCompact",
-      "subAgentThreadSpawn",
-      "subAgentOther",
-      "unknown"
-    ]
-  ];
-  for (const archived of archivedModes) {
-    for (const sourceKinds of sourcePasses) {
-      let cursor;
-      while (true) {
-        const response = await codex.request("thread/list", {
-          limit: 50,
-          sortKey: "updated_at",
-          sortDirection: "desc",
-          archived,
-          useStateDbOnly: true,
-          ...cursor === undefined ? {} : { cursor },
-          ...sourceKinds === undefined ? {} : { sourceKinds }
-        });
-        if ("error" in response) {
-          throw new Error(`thread/list failed: ${response.error.message}`);
-        }
-        const result = objectValue(response.result);
-        const data = arrayValue(result?.data)?.filter(isJsonObject) ?? [];
-        for (const thread of data) {
-          const row = codexThreadHistoryRow(thread, archived);
-          const id = stringValue(objectValue(row)?.id);
-          if (id !== undefined && id !== "" && !rowsById.has(id)) {
-            rowsById.set(id, row);
-          }
-        }
-        const nextCursor = stringValue(result?.nextCursor);
-        if (nextCursor === undefined || nextCursor === "" || data.length === 0) {
-          break;
-        }
-        cursor = nextCursor;
-      }
-    }
-  }
-  return Array.from(rowsById.values()).sort(compareCodexThreadHistoryRows);
-}
-function codexThreadHistoryRow(thread, archived) {
-  const gitInfo = objectValue(thread.gitInfo);
-  const preview = stringValue(thread.preview) ?? "";
-  const name = stringValue(thread.name) ?? "";
-  const title = stringValue(thread.title) ?? (name === "" ? preview : name);
-  const description = stringValue(thread.description) ?? stringValue(thread.summary) ?? preview;
-  return {
-    id: stringValue(thread.id) ?? "",
-    title: title ?? "",
-    description: description ?? "",
-    preview: preview.replace(/\s+/g, " ").trim(),
-    cwd: stringValue(thread.cwd) ?? "",
-    source: stringValue(thread.source) ?? "",
-    createdAt: codexTimestamp(thread.createdAt),
-    updatedAt: codexTimestamp(thread.updatedAt),
-    archived,
-    modelProvider: stringValue(thread.modelProvider) ?? "",
-    cliVersion: stringValue(thread.cliVersion) ?? "",
-    gitBranch: stringValue(gitInfo?.branch) ?? "",
-    gitOriginUrl: stringValue(gitInfo?.originUrl) ?? "",
-    path: stringValue(thread.path) ?? ""
-  };
-}
-function codexTimestamp(value) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return new Date(value * 1000).toISOString();
-  }
-  return stringValue(value) ?? "";
-}
-function compareCodexThreadHistoryRows(left, right) {
-  const leftRow = objectValue(left);
-  const rightRow = objectValue(right);
-  const leftTime = Date.parse(stringValue(leftRow?.createdAt) ?? stringValue(leftRow?.updatedAt) ?? "");
-  const rightTime = Date.parse(stringValue(rightRow?.createdAt) ?? stringValue(rightRow?.updatedAt) ?? "");
-  return safeComparableTime(leftTime) - safeComparableTime(rightTime);
-}
-function safeComparableTime(value) {
-  return Number.isFinite(value) ? value : Number.MAX_SAFE_INTEGER;
-}
 function extractStartedThreadId(response) {
   if ("error" in response) {
     throw new Error(`thread/start failed: ${response.error.message}`);
@@ -18340,6 +18236,7 @@ async function waitForFileChangeOrTimeout(path, deadline, now, ready2 = () => fa
 var flagDefinitions = new Map([
   ["version", { kind: "boolean" }],
   ["api-url", { kind: "value" }],
+  ["linzumi-url", { kind: "value" }],
   ["token", { kind: "value" }],
   ["runner-id", { kind: "value" }],
   ["cwd", { kind: "value" }],
@@ -18354,6 +18251,7 @@ var flagDefinitions = new Map([
   ["reasoning-effort", { kind: "value" }],
   ["sandbox", { kind: "value" }],
   ["approval-policy", { kind: "value" }],
+  ["allow-port-forwarding-by-default", { kind: "boolean" }],
   ["stream-flush-ms", { kind: "value" }],
   ["allowed-cwd", { kind: "value" }],
   ["forward-port", { kind: "value" }],
@@ -18733,7 +18631,7 @@ async function runAuthCommand(args) {
     process.stdout.write(helpText());
     return;
   }
-  const kandanUrl = required(values, "api-url");
+  const kandanUrl = requiredKandanUrl(values);
   const target = parseOptionalChannelTarget(values);
   const token = await acquireLocalRunnerTokenDetails({
     kandanUrl,
@@ -18764,7 +18662,7 @@ async function parseStartRunnerArgs(args, deps = {
     process.exit(0);
   }
   rejectStartTargetingFlags(values);
-  const kandanUrl = stringValue4(values, "api-url") ?? defaultLinzumiWebSocketUrl;
+  const kandanUrl = kandanUrlValue(values) ?? defaultLinzumiWebSocketUrl;
   const requestedCwd = resolveUserPath(cwdArg ?? process.cwd());
   const cwd = assertConfiguredAllowedCwds([requestedCwd])[0] ?? requestedCwd;
   const explicitAllowedCwds = values.has("allowed-cwd") ? assertConfiguredAllowedCwds(parseAllowedCwdList(stringValue4(values, "allowed-cwd"))) : [];
@@ -18848,6 +18746,7 @@ async function parseStartRunnerArgs(args, deps = {
       reasoningEffort: stringValue4(values, "reasoning-effort"),
       sandbox: stringValue4(values, "sandbox"),
       approvalPolicy: stringValue4(values, "approval-policy"),
+      allowPortForwardingByDefault: booleanFlagValue(values, "allow-port-forwarding-by-default"),
       streamFlushMs: positiveIntegerValue2(values, "stream-flush-ms")
     }
   };
@@ -18880,9 +18779,10 @@ async function parseAgentRunnerArgs(args, deps = {
     reasoningEffort: stringValue4(values, "reasoning-effort"),
     sandbox: stringValue4(values, "sandbox"),
     approvalPolicy: stringValue4(values, "approval-policy"),
+    allowPortForwardingByDefault: booleanFlagValue(values, "allow-port-forwarding-by-default"),
     streamFlushMs: positiveIntegerValue2(values, "stream-flush-ms")
   };
-  const kandanUrl = stringValue4(values, "api-url") ?? agentApiUrlToKandanUrl(tokenFile.apiUrl);
+  const kandanUrl = kandanUrlValue(values) ?? agentApiUrlToKandanUrl(tokenFile.apiUrl);
   const requestedCwdValue = cwdArg ?? stringValue4(values, "cwd");
   const requestedCwd = resolveUserPath(requestedCwdValue ?? process.cwd());
   const configuredAllowedCwds2 = requestedCwdValue === undefined && !values.has("allowed-cwd") ? readConfiguredAllowedCwdDetailsForLinzumiUrl(kandanUrl) : { allowedCwds: [], missingAllowedCwds: [] };
@@ -19014,7 +18914,7 @@ async function parseRunnerArgs(args, deps = {
   }
   rejectConnectChannelFlags(values);
   const workspaceSlug = stringValue4(values, "workspace");
-  const kandanUrl = stringValue4(values, "api-url") ?? defaultLinzumiWebSocketUrl;
+  const kandanUrl = kandanUrlValue(values) ?? defaultLinzumiWebSocketUrl;
   const cwd = stringValue4(values, "cwd") ?? process.cwd();
   const cwdAllowedCwds = assertConfiguredAllowedCwds([cwd]);
   const localConfiguredAllowedCwds = values.has("allowed-cwd") ? { allowedCwds: [], missingAllowedCwds: [] } : readConfiguredAllowedCwdDetailsForLinzumiUrl(kandanUrl);
@@ -19073,9 +18973,27 @@ function runnerRuntimeDefaultsFromValues(values) {
     reasoningEffort: stringValue4(values, "reasoning-effort"),
     approvalPolicy: stringValue4(values, "approval-policy"),
     sandbox: stringValue4(values, "sandbox"),
-    allowPortForwardingByDefault: undefined
+    allowPortForwardingByDefault: booleanFlagValue(values, "allow-port-forwarding-by-default")
   };
 }
+function kandanUrlValue(values) {
+  const apiUrl = stringValue4(values, "api-url");
+  const linzumiUrl = stringValue4(values, "linzumi-url");
+  if (apiUrl !== undefined && linzumiUrl !== undefined && apiUrl !== linzumiUrl) {
+    throw new Error("use only one of --api-url or --linzumi-url");
+  }
+  return apiUrl ?? linzumiUrl;
+}
+function requiredKandanUrl(values) {
+  const value = kandanUrlValue(values);
+  if (value === undefined) {
+    throw new Error("missing required flag: --api-url or --linzumi-url");
+  }
+  return value;
+}
+function booleanFlagValue(values, key) {
+  return values.get(key) === true ? true : undefined;
+}
 function strictFlagValues(args, definitions = flagDefinitions) {
   const values = new Map;
   for (let index = 0;index < args.length; index += 1) {
@@ -19282,6 +19200,7 @@ Usage:
 
 Connection:
   --api-url <url>             Linzumi API URL, default ${defaultLinzumiWebSocketUrl}
+  --linzumi-url <url>         Alias for --api-url
   --token <jwt>               Optional override token. Otherwise ~/.linzumi/auth.json is validated or OAuth opens.
   --auth-file <path>          Auth cache path, default ~/.linzumi/auth.json
   --oauth-callback-host <ip>  Callback host reachable by your browser
@@ -19298,6 +19217,8 @@ Codex:
   --reasoning-effort <value>  Reasoning effort requested for Codex and shown in Linzumi
   --sandbox <value>           Sandbox metadata shown in Linzumi
   --approval-policy <value>   Approval-policy metadata shown in Linzumi
+  --allow-port-forwarding-by-default
+                              Auto-approve detected port-forward candidates for started sessions
   --stream-flush-ms <ms>      Batch live Codex deltas before Linzumi persistence, default 150
   --fast                      Mark this runner as low-latency/fast in the availability message
   --log-file <path>           JSONL event log path, default <cwd>/.linzumi-runner.log

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "0.0.52-beta",
+  "version": "0.0.53-beta",
   "description": "Linzumi CLI — point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {