@codeoid/core 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codeoid/core",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Framework-agnostic Codeoid client core — WebSocket transport (auth handshake, reconnect, heartbeat), message store semantics, resume cursors, and display helpers. Shared by the web UI and the mobile client.",
   "license": "MIT",
   "type": "module",
@@ -23,6 +23,6 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@codeoid/protocol": "^0.1.0"
+    "@codeoid/protocol": "^0.2.0"
   }
 }

package/src/client.ts

@@ -34,6 +34,22 @@ export type ClientStatus =
   | { kind: "reconnecting"; attempt: number; nextInMs: number; reason: string }
   | { kind: "failed"; reason: string };
 
+/**
+ * The daemon actively REJECTED the presented token (auth `response.error`, or a
+ * close with the auth codes 4001/4003) — as opposed to a transient network
+ * drop. Retrying won't help: there's no refresh path for an OAuth JWT, and a
+ * key that fails re-exchange won't recover. The reconnect loop treats this as
+ * terminal (→ `failed`) so the host can fall back to sign-in instead of
+ * looping forever on a dead token.
+ */
+export class AuthRejectedError extends Error {
+  readonly authRejected = true as const;
+  constructor(message: string) {
+    super(message);
+    this.name = "AuthRejectedError";
+  }
+}
+
 export interface ConnectOptions {
   url: string; // ws://host:port — daemon's WS endpoint
   /** Initial access token used for the first handshake (and the fallback
@@ -331,7 +347,10 @@ export class CodeoidClient {
           return auth;
         } catch (err) {
           const reason = err instanceof Error ? err.message : String(err);
-          if (isBounded && attempt >= max) {
+          // Terminal auth rejection (bad/expired token, no refresh path — e.g.
+          // an OAuth JWT that expired) never self-heals by retrying; fail so the
+          // host falls back to sign-in instead of looping forever on it.
+          if (err instanceof AuthRejectedError || (isBounded && attempt >= max)) {
             this.#setStatus({ kind: "failed", reason });
             throw err;
           }
@@ -530,7 +549,7 @@ export class CodeoidClient {
         if (!authResolved && msg.type === "response.error") {
           authResolved = true;
           clearTimeout(authTimer);
-          reject(new Error(`auth rejected: ${msg.error}`));
+          reject(new AuthRejectedError(`auth rejected: ${msg.error}`));
           return;
         }
         this.#routeMessage(msg);
@@ -540,7 +559,13 @@ export class CodeoidClient {
         if (!authResolved) {
           authResolved = true;
           clearTimeout(authTimer);
-          reject(new Error(reason));
+          // 4001 (auth handshake timeout) / 4003 (auth rejected) are the
+          // daemon's auth-failure close codes — terminal, not a retryable drop.
+          reject(
+            ev.code === 4001 || ev.code === 4003
+              ? new AuthRejectedError(reason)
+              : new Error(reason),
+          );
           return;
         }
         clearTimeout(authTimer);

package/src/slash.ts

@@ -16,6 +16,7 @@
 
 import type {
   ClientMessage,
+  SessionInfo,
   SessionMode,
 } from "@codeoid/protocol";
 
@@ -28,15 +29,26 @@ export type SlashCommand =
   | { kind: "mode"; mode: SessionMode; maxTurns?: number }
   | { kind: "model"; model: string; fallback?: string | null }
   | { kind: "model-picker" }
+  | { kind: "provider"; providerId: string }
   | { kind: "help" }
   | { kind: "clear" }
   | { kind: "who" }
   | { kind: "capabilities"; tab: "agents" | "skills" | "mcp" | "hooks" }
   | { kind: "export" }
   | { kind: "import" }
-  | { kind: "fork" };
+  | { kind: "fork"; providerId?: string };
 
-export function parseSlash(raw: string): SlashCommand | null {
+export interface ParseSlashOptions {
+  /**
+   * Provider-command passthrough (`session.commands` catalogs). When the
+   * verb is not a built-in and this predicate matches it, `parseSlash`
+   * returns null — "not a client command" — so the caller sends the raw
+   * text as a normal prompt and the session's provider expands it.
+   */
+  isProviderCommand?: (name: string) => boolean;
+}
+
+export function parseSlash(raw: string, opts?: ParseSlashOptions): SlashCommand | null {
   const trimmed = raw.trim();
   if (!trimmed.startsWith("/")) return null;
   const head = trimmed.slice(1);
@@ -96,6 +108,13 @@ export function parseSlash(raw: string): SlashCommand | null {
         ...(fallback !== undefined ? { fallback } : {}),
       };
     }
+    case "provider": {
+      // Switch the focused session's BACKEND (e.g. `/provider pi`). The
+      // daemon validates the id fail-closed and rejects mid-turn switches.
+      const providerId = rest[0]?.toLowerCase();
+      if (!providerId) throw new Error("/provider <id> — e.g. /provider pi");
+      return { kind: "provider", providerId };
+    }
     case "help":
       return { kind: "help" };
     case "clear":
@@ -120,8 +139,14 @@ export function parseSlash(raw: string): SlashCommand | null {
     case "import":
       return { kind: "import" };
     case "fork":
-      return { kind: "fork" };
+      // `/fork [backend]` — branch the CURRENT session, optionally onto a
+      // different backend. (Historically an alias for /import, which
+      // silently discarded the argument and opened the bundle dialog.)
+      return { kind: "fork", providerId: rest[0]?.toLowerCase() };
     default:
+      // Not a built-in. Provider commands (pi extensions, prompt templates,
+      // skills) pass through as plain prompt text — the provider expands them.
+      if (opts?.isProviderCommand?.(verb.toLowerCase())) return null;
       throw new Error(`unknown slash command: /${verb}`);
   }
 }
@@ -147,6 +172,12 @@ export interface SlashContext {
   showCapabilities?: (tab: "agents" | "skills" | "mcp" | "hooks") => void;
   showExport?: () => void;
   showImport?: () => void;
+  /**
+   * Called with the fork's SessionInfo after a successful `/fork`, so the
+   * frontend can add it to its store and focus it. Absent = the daemon's
+   * `session.list` broadcast is the only signal.
+   */
+  onSessionForked?: (session: SessionInfo) => void;
 }
 
 export function dispatchSlash(cmd: SlashCommand, ctx: SlashContext): void {
@@ -224,6 +255,14 @@ export function dispatchSlash(cmd: SlashCommand, ctx: SlashContext): void {
     case "model-picker":
       ctx.showModelPicker?.();
       return;
+    case "provider":
+      fire({
+        type: "session.set_provider",
+        id: ctx.newRequestId(),
+        sessionId: ctx.sessionId,
+        providerId: cmd.providerId,
+      });
+      return;
     case "help":
       ctx.showHelp?.();
       return;
@@ -240,8 +279,28 @@ export function dispatchSlash(cmd: SlashCommand, ctx: SlashContext): void {
       ctx.showExport?.();
       return;
     case "import":
-    case "fork":
       ctx.showImport?.();
       return;
+    case "fork": {
+      const msg: ClientMessage = {
+        type: "session.fork",
+        id: ctx.newRequestId(),
+        sessionId: ctx.sessionId,
+        ...(cmd.providerId ? { providerId: cmd.providerId } : {}),
+      };
+      if (ctx.request) {
+        ctx
+          .request(msg)
+          .then((data) => {
+            if (data && typeof data === "object" && "id" in data) {
+              ctx.onSessionForked?.(data as SessionInfo);
+            }
+          })
+          .catch((e) => ctx.report?.(e instanceof Error ? e.message : String(e)));
+      } else {
+        ctx.send(msg);
+      }
+      return;
+    }
   }
 }