@linzumi/cli 0.0.3-beta → 0.0.5-beta

package/README.md

@@ -27,7 +27,7 @@ runner. It wraps the same local runner that was previously started with
 Install the exact beta version:
 
 ```bash
-npm install -g @linzumi/cli@0.0.3-beta
+npm install -g @linzumi/cli@0.0.5-beta
 ```
 
 Or install the current beta tag:
@@ -47,7 +47,7 @@ linzumi --version
 Expected CLI output:
 
 ```bash
-linzumi 0.0.3-beta
+linzumi 0.0.5-beta
 ```
 
 ## Prod Quick Start
@@ -55,19 +55,19 @@ linzumi 0.0.3-beta
 For the Linzumi workspace in prod, this is the first command to try:
 
 ```bash
-npm install -g @linzumi/cli@0.0.3-beta
+npm install -g @linzumi/cli@0.0.5-beta
 
 linzumi connect \
   --kandan-url wss://serve.kandanai.com \
   --workspace linzumi \
   --channel seans-playground \
-  --listen-user sean \
   --codex-bin codex \
   --launch-tui
 ```
 
 The runner handles OAuth itself. If the cached Kandan token is missing or
 rejected, it opens the OAuth flow and saves the refreshed auth cache.
+By default it listens for replies from the authenticated Kandan user.
 
 For a more explicit launch that pins the Codex model, reasoning effort, and
 fast service tier:
@@ -77,7 +77,6 @@ linzumi connect \
   --kandan-url wss://serve.kandanai.com \
   --workspace linzumi \
   --channel seans-playground \
-  --listen-user sean \
   --codex-bin codex \
   --model gpt-5.5 \
   --reasoning-effort low \
@@ -100,7 +99,6 @@ linzumi connect \
   --kandan-url wss://serve.kandanai.com \
   --workspace linzumi \
   --channel seans-playground \
-  --listen-user sean \
   --codex-bin codex \
   --launch-tui
 ```
@@ -130,7 +128,7 @@ linzumi auth [auth options]
 --workspace <slug>          Workspace slug, for example linzumi
 --channel <slug|w/c>        Channel slug, or workspace/channel
 --kandan-thread-id <uuid>   Resume an existing Kandan thread
---listen-user <user|all>    User whose replies are accepted, or all
+--listen-user <user|all>    User whose replies are accepted, default authenticated user
 --cwd <path>                Working directory for Codex
 --codex-bin <path>          Codex executable, default codex
 --model <name>              Codex model

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "0.0.3-beta",
+  "version": "0.0.5-beta",
   "description": "Linzumi local Codex runner CLI.",
   "type": "module",
   "bin": {

package/src/channelSessionSupport.ts

@@ -139,18 +139,18 @@ export function senderAllowed(
   event: Pick<KandanChatEvent, "actorSlug" | "actorUserId">,
   runnerIdentity: RunnerIdentity,
 ): boolean {
-  const normalized = listenUser.trim();
+  const normalized = listenUser.trim().toLocaleLowerCase();
 
   if (normalized === "all") {
     return true;
   }
 
-  if (event.actorSlug !== undefined && event.actorSlug === normalized) {
+  if (event.actorSlug !== undefined && event.actorSlug.toLocaleLowerCase() === normalized) {
     return true;
   }
 
   return (
-    runnerIdentity.actorUsername === normalized &&
+    runnerIdentity.actorUsername?.toLocaleLowerCase() === normalized &&
     runnerIdentity.actorUserId !== undefined &&
     event.actorUserId === runnerIdentity.actorUserId
   );

package/src/index.ts

@@ -18,6 +18,7 @@ import { randomUUID } from "node:crypto";
 import { runLocalCodexRunner, type RunnerOptions } from "./runner";
 import { writeCachedLocalRunnerToken } from "./authCache";
 import { resolveLocalRunnerToken } from "./authResolution";
+import { identityFromAccessToken } from "./channelSessionSupport";
 import { acquireLocalRunnerTokenDetails } from "./oauth";
 
 type FlagDefinition = {
@@ -48,11 +49,13 @@ const flagDefinitions = new Map<string, FlagDefinition>([
   ["help", { kind: "boolean" }],
 ]);
 
-try {
-  await main(process.argv.slice(2));
-} catch (error) {
-  process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-  process.exit(1);
+if (import.meta.main) {
+  try {
+    await main(process.argv.slice(2));
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+  }
 }
 
 async function main(args: readonly string[]): Promise<void> {
@@ -63,7 +66,7 @@ async function main(args: readonly string[]): Promise<void> {
       process.stdout.write(connectGuideText());
       return;
     case "version":
-      process.stdout.write("linzumi 0.0.3-beta\n");
+      process.stdout.write("linzumi 0.0.5-beta\n");
       return;
     case "auth":
       await runAuthCommand(parsed.args);
@@ -132,7 +135,7 @@ async function runAuthCommand(args: readonly string[]): Promise<void> {
   process.stdout.write(`Saved Kandan local runner auth for ${cached.kandanBaseUrl}\n`);
 }
 
-async function parseRunnerArgs(args: readonly string[]): Promise<RunnerOptions> {
+export async function parseRunnerArgs(args: readonly string[]): Promise<RunnerOptions> {
   const values = strictFlagValues(args);
 
   if (values.get("help") === true) {
@@ -141,24 +144,25 @@ async function parseRunnerArgs(args: readonly string[]): Promise<RunnerOptions>
   }
 
   if (values.get("version") === true) {
-    process.stdout.write("linzumi 0.0.3-beta\n");
+    process.stdout.write("linzumi 0.0.5-beta\n");
     process.exit(0);
   }
 
-  const channelSession = parseChannelSession(values);
+  const channelTarget = parseChannelSessionTarget(values);
   const kandanUrl = required(values, "kandan-url");
   const explicitToken = stringValue(values, "token");
   const token = await resolveLocalRunnerToken({
       kandanUrl,
       explicitToken,
-      workspaceSlug: channelSession?.workspaceSlug,
-      channelSlug: channelSession?.channelSlug,
+      workspaceSlug: channelTarget?.workspaceSlug,
+      channelSlug: channelTarget?.channelSlug,
       authFilePath: stringValue(values, "auth-file"),
       callbackHost: stringValue(values, "oauth-callback-host"),
       reportRejectedCachedToken: () => {
         process.stderr.write("Cached Kandan local runner auth was rejected; starting OAuth.\n");
       },
     });
+  const channelSession = parseChannelSession(values, token, channelTarget);
 
   return {
     kandanUrl,
@@ -210,15 +214,16 @@ function strictFlagValues(args: readonly string[]): Map<string, string | true> {
 }
 
 function parseChannelSession(
-  values: Map<string, string | true>
+  values: Map<string, string | true>,
+  token: string,
+  target: { readonly workspaceSlug: string; readonly channelSlug: string } | undefined,
 ): RunnerOptions["channelSession"] {
-  const target = parseOptionalChannelTarget(values);
-
   if (target === undefined) {
     return undefined;
   }
 
-  const listenUser = required(values, "listen-user");
+  const listenUser =
+    stringValue(values, "listen-user") ?? defaultListenUserFromToken(token);
 
   return {
     workspaceSlug: target.workspaceSlug,
@@ -232,6 +237,22 @@ function parseChannelSession(
   };
 }
 
+function parseChannelSessionTarget(
+  values: Map<string, string | true>
+): { readonly workspaceSlug: string; readonly channelSlug: string } | undefined {
+  return parseOptionalChannelTarget(values);
+}
+
+function defaultListenUserFromToken(token: string): string {
+  const username = identityFromAccessToken(token).actorUsername;
+
+  if (username !== undefined) {
+    return username;
+  }
+
+  throw new Error("missing --listen-user and authenticated user is unavailable");
+}
+
 function parseOptionalChannelTarget(
   values: Map<string, string | true>
 ): { readonly workspaceSlug: string; readonly channelSlug: string } | undefined {
@@ -297,7 +318,7 @@ function helpText(): string {
 
 Usage:
   linzumi
-  linzumi connect --kandan-url <ws-url> --workspace <slug> --channel <slug> --listen-user <username|all> [options]
+  linzumi connect --kandan-url <ws-url> --workspace <slug> --channel <slug> [options]
   linzumi auth --kandan-url <ws-url> [--workspace <slug> --channel <slug>]
 
 Required:
@@ -310,7 +331,7 @@ Channel binding:
   --workspace <slug>          Workspace slug
   --channel <slug|w/c>        Channel slug, or workspace/channel
   --kandan-thread-id <uuid>   Resume an existing Kandan thread instead of announcing a new root
-  --listen-user <user|all>    User whose replies are accepted, or all
+  --listen-user <user|all>    User whose replies are accepted, default authenticated user
 
 Codex:
   --cwd <path>                Working directory for Codex, default current directory
@@ -326,17 +347,17 @@ Codex:
 
 Examples:
   Good:
-    linzumi connect --kandan-url wss://serve.kandanai.com --workspace linzumi --channel seans-playground --listen-user sean --codex-bin codex --launch-tui
-    linzumi connect --kandan-url wss://serve.kandanai.com --workspace linzumi --channel seans-playground --listen-user sean --codex-bin codex --model gpt-5.5 --reasoning-effort low --fast --launch-tui
+    linzumi connect --kandan-url wss://serve.kandanai.com --workspace linzumi --channel seans-playground --codex-bin codex --launch-tui
+    linzumi connect --kandan-url wss://serve.kandanai.com --workspace linzumi --channel seans-playground --codex-bin codex --model gpt-5.5 --reasoning-effort low --fast --launch-tui
     linzumi auth --kandan-url ws://127.0.0.1:4160 --workspace default --channel seans-playground
     linzumi auth --kandan-url ws://100.71.192.98:4160 --oauth-callback-host 100.71.192.98 --workspace default --channel seans-playground
-    linzumi connect --kandan-url ws://127.0.0.1:4160 --token "$TOKEN" --workspace default --channel seans-playground --listen-user sean --cwd /tmp/kandan-runner-a
-    linzumi connect --kandan-url ws://127.0.0.1:4160 --workspace default --channel seans-playground --listen-user sean
+    linzumi connect --kandan-url ws://127.0.0.1:4160 --token "$TOKEN" --workspace default --channel seans-playground --cwd /tmp/kandan-runner-a
+    linzumi connect --kandan-url ws://127.0.0.1:4160 --workspace default --channel seans-playground
     linzumi connect --kandan-url ws://127.0.0.1:4160 --token "$TOKEN" --channel default/seans-playground --listen-user all --launch-tui
 
   Bad:
-    linzumi connect --kandan-url ws://127.0.0.1:4160 --workspace default --channel seans-playground
-      Missing --listen-user.
+    linzumi connect --kandan-url ws://127.0.0.1:4160 --token not-a-jwt --workspace default --channel seans-playground
+      Missing --listen-user and authenticated user is unavailable.
     linzumi connect --kandan-url ws://127.0.0.1:4160 --token "$TOKEN" --listen-users sean
       Invalid flag: use --listen-user.
 `;
@@ -348,7 +369,7 @@ function connectGuideText(): string {
 Connect this computer to Kandan as a local Codex runner.
 
 Use:
-  linzumi connect --kandan-url <ws-url> --workspace <slug> --channel <slug> --listen-user <username|all> [options]
+  linzumi connect --kandan-url <ws-url> --workspace <slug> --channel <slug> [options]
 
 For help:
   linzumi connect --help

package/src/phoenix.ts

@@ -13,6 +13,11 @@
   Spec: plans/2026-04-24-local-codex-runner-deep-quality-spec.md
   Relationship: Treats the Kandan websocket as a reconnectable transport so
   server restarts do not terminate the durable local Codex session.
+
+- Date: 2026-04-26
+  Spec: plans/2026_04_26_linzumi_cli_review_followups_note.md
+  Relationship: Treats non-ok Phoenix replies for runner pushes as transport
+  failures so failed Kandan writes cannot be mistaken for synchronized state.
 */
 import {
   type JsonObject,
@@ -23,6 +28,7 @@ import {
 } from "./protocol";
 
 type PendingPush = {
+  readonly event: string;
   readonly resolve: (payload: JsonValue) => void;
   readonly reject: (error: Error) => void;
 };
@@ -112,6 +118,8 @@ export async function connectPhoenixClient(
 
         if (name === "phx_error") {
           pendingPush.reject(new Error("phoenix push failed"));
+        } else if (isNonOkPushReply(payload) && pendingPush.event !== "phx_join") {
+          pendingPush.reject(new Error(`phoenix push failed: ${replyErrorMessage(payload)}`));
         } else {
           pendingPush.resolve(payload);
         }
@@ -143,7 +151,7 @@ export async function connectPhoenixClient(
     const frame: PhoenixFrame = [null, ref, topic, event, payload];
 
     return new Promise((resolve, reject) => {
-      pending.set(ref, { resolve, reject });
+      pending.set(ref, { event, resolve, reject });
       websocket.send(JSON.stringify(frame));
     });
   };
@@ -304,6 +312,10 @@ function isJoinReply(value: JsonValue): value is {
 }
 
 function joinErrorMessage(value: JsonValue): string {
+  return replyErrorMessage(value);
+}
+
+function replyErrorMessage(value: JsonValue): string {
   if (!isJsonObject(value)) {
     return "invalid reply";
   }
@@ -321,6 +333,10 @@ function joinErrorMessage(value: JsonValue): string {
   return "unknown";
 }
 
+function isNonOkPushReply(value: JsonValue): boolean {
+  return isJsonObject(value) && value.status !== "ok";
+}
+
 function isKandanControl(value: JsonValue): value is KandanControl {
   return isJsonObject(value) && typeof value.type === "string";
 }

package/src/runner.ts

@@ -30,6 +30,11 @@
   Relationship: Leaves channel-scoped approval controls to `channelSession.ts`
   so the process runner remains lifecycle-only while Kandan safely resolves
   Codex app-server approval requests from the thread UI.
+
+- Date: 2026-04-26
+  Spec: plans/2026_04_26_linzumi_cli_review_followups_note.md
+  Relationship: Rejects stale Kandan controls for previous local runner
+  instances before they can mutate the current Codex app-server session.
 */
 import { spawn, type ChildProcess } from "node:child_process";
 import { randomUUID } from "node:crypto";
@@ -270,6 +275,16 @@ async function openLocalCodexRunner(
 
   kandan.onControl(control => {
     log("kandan.control", { control });
+    if (!controlTargetsInstance(control, instanceId)) {
+      log("kandan.control_ignored", {
+        reason: "instance_id_mismatch",
+        instanceId,
+        controlInstanceId: control.instanceId,
+        controlType: control.type,
+      });
+      return;
+    }
+
     void (channelSession?.handleControl(control) ?? Promise.resolve(undefined))
       .then(handled => {
         if (handled !== undefined) {
@@ -286,12 +301,21 @@ async function openLocalCodexRunner(
           instanceId,
           message: error instanceof Error ? error.message : String(error),
         });
+      })
+      .catch(error => {
+        log("kandan.control_response_push_failed", {
+          message: error instanceof Error ? error.message : String(error),
+        });
       });
   });
 
   return { instanceId, codexUrl, close };
 }
 
+function controlTargetsInstance(control: KandanControl, instanceId: string): boolean {
+  return control.instanceId === undefined || control.instanceId === instanceId;
+}
+
 async function closeCleanupStack(cleanup: CleanupStack): Promise<void> {
   if (cleanup.closePromise !== undefined) {
     return cleanup.closePromise;