@vibe80/vibe80 0.1.7 → 0.1.8

package/bin/vibe80.js

@@ -19,6 +19,9 @@ const defaultEnv = {
 };
 const deploymentMode = process.env.DEPLOYMENT_MODE || defaultEnv.DEPLOYMENT_MODE;
 const serverPort = process.env.PORT || "5179";
+const cliArgs = process.argv.slice(2);
+const enableCodexFromCli = cliArgs.includes("--codex");
+const enableClaudeFromCli = cliArgs.includes("--claude");
 
 const spawnProcess = (cmd, args, label, extraEnv = {}) => {
   const child = spawn(cmd, args, {
@@ -127,11 +130,21 @@ const shutdown = (code = 0) => {
 
 const startServer = () => {
   unlinkMonoAuthUrlFile();
+  const monoProviderEnv = {};
+  if (enableCodexFromCli) {
+    monoProviderEnv.VIBE80_MONO_ENABLE_CODEX = "true";
+  }
+  if (enableClaudeFromCli) {
+    monoProviderEnv.VIBE80_MONO_ENABLE_CLAUDE = "true";
+  }
   server = spawnProcess(
     process.execPath,
     ["server/src/index.js"],
     "server",
-    { VIBE80_MONO_AUTH_URL_FILE: monoAuthUrlFile }
+    {
+      VIBE80_MONO_AUTH_URL_FILE: monoAuthUrlFile,
+      ...monoProviderEnv,
+    }
   );
   void maybeOpenMonoAuthUrl();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe80/vibe80",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "private": false,
   "workspaces": [
     "server",

package/server/src/claudeClient.js

@@ -48,7 +48,7 @@ export class ClaudeCliClient extends EventEmitter {
     this.tmpDir = tmpDir || null;
     this.sessionId = sessionId || null;
     this.worktreeId = worktreeId || "main";
-    this.ready = false;
+    this.ready = true;
     this.threadId = threadId || null;
     this.pendingForkFromThreadId = forkFromThreadId || null;
     this.modelInfo = null;
@@ -77,7 +77,6 @@ export class ClaudeCliClient extends EventEmitter {
       return;
     }
     this.activeProcess = null;
-    this.ready = false;
     const exitPromise = new Promise((resolve) => {
       proc.once("exit", resolve);
       proc.once("close", resolve);
@@ -223,6 +222,7 @@ export class ClaudeCliClient extends EventEmitter {
       cwd: isMonoUser ? this.cwd : undefined,
     });
     this.activeProcess = proc;
+    this.ready = false;
 
     proc.stdout.setEncoding("utf8");
     proc.stdout.on("data", (chunk) => {
@@ -264,6 +264,7 @@ export class ClaudeCliClient extends EventEmitter {
       if (this.activeProcess === proc) {
         this.activeProcess = null;
       }
+      this.ready = true;
       this.#flushLogBuffer("OUT", "stdoutLogBuffer");
       this.#flushLogBuffer("ERR", "stderrLogBuffer");
       this.providerLogger?.close?.();

package/server/src/index.js

@@ -662,9 +662,20 @@ wss.on("connection", (socket, req) => {
           return;
         }
         const isMainWorktree = worktreeId === "main";
-        const client = isMainWorktree
+        let client = isMainWorktree
           ? getActiveClient(session)
           : runtime.worktreeClients.get(worktreeId);
+        if (isMainWorktree && !client) {
+          const provider = session.activeProvider === "claude" ? "claude" : "codex";
+          client = await getOrCreateClient(session, provider);
+          if (!client.listenerCount("ready")) {
+            if (provider === "claude") {
+              attachClaudeEvents(sessionId, client, provider);
+            } else {
+              attachClientEvents(sessionId, client, provider);
+            }
+          }
+        }
         if (!client?.ready) {
           const label = isMainWorktree
             ? getProviderLabel(session)
@@ -1146,6 +1157,20 @@ wss.on("connection", (socket, req) => {
             });
           });
         }
+      } else if (session.activeProvider === "claude") {
+        const client = await getOrCreateClient(session, "claude");
+        if (!client.listenerCount("ready")) {
+          attachClaudeEvents(sessionId, client, "claude");
+        }
+        if (!client.ready && !client.activeProcess) {
+          client.start().catch((error) => {
+            console.error("Failed to restart Claude CLI:", error);
+            broadcastToSession(sessionId, {
+              type: "error",
+              message: "Claude CLI failed to start.",
+            });
+          });
+        }
       }
 
       authenticated = true;

package/server/src/routes/worktrees.js

@@ -430,9 +430,20 @@ export default function worktreeRoutes(deps) {
 
     const isMainWorktree = worktreeId === "main";
     const runtime = getSessionRuntime(sessionId);
-    const client = isMainWorktree
+    let client = isMainWorktree
       ? getActiveClient(session)
       : runtime?.worktreeClients?.get(worktreeId);
+    if (isMainWorktree && !client) {
+      const provider = session.activeProvider === "claude" ? "claude" : "codex";
+      client = await getOrCreateClient(session, provider);
+      if (!client.listenerCount("ready")) {
+        if (provider === "claude") {
+          attachClaudeEvents(sessionId, client, provider);
+        } else {
+          attachClientEvents(sessionId, client, provider);
+        }
+      }
+    }
     if (!client?.ready) {
       const label = isMainWorktree
         ? worktree.provider === "claude"

package/server/src/services/workspace.js

@@ -765,14 +765,12 @@ export const ensureDefaultMonoWorkspace = async () => {
     return;
   }
   const workspaceId = "default";
+  const enabledProviders = getMonoEnabledProvidersFromEnv();
   await ensureWorkspaceDirs(workspaceId);
   const ids = await getWorkspaceUserIds(workspaceId);
   const existing = await storage.getWorkspace(workspaceId);
   if (!existing) {
-    const providers = {
-      codex: { enabled: true, auth: null },
-      claude: { enabled: true, auth: null },
-    };
+    const providers = applyMonoEnabledProviders({}, enabledProviders);
     await persistWorkspaceRecord({
       workspaceId,
       providers,
@@ -781,12 +779,69 @@ export const ensureDefaultMonoWorkspace = async () => {
       existing: null,
     });
     await appendAuditLog(workspaceId, "workspace_created");
+    return;
   }
+  const providers = applyMonoEnabledProviders(existing.providers || {}, enabledProviders);
+  await persistWorkspaceRecord({
+    workspaceId,
+    providers,
+    ids,
+    existing,
+  });
+  await appendAuditLog(workspaceId, "workspace_providers_activation_updated", {
+    codexEnabled: providers.codex?.enabled ?? false,
+    claudeEnabled: providers.claude?.enabled ?? false,
+  });
 };
 
 const readEnvValue = (name) =>
   typeof process.env[name] === "string" ? process.env[name].trim() : "";
 
+const parseMonoEnableEnv = (name) => {
+  const raw = process.env[name];
+  if (typeof raw !== "string") {
+    return false;
+  }
+  const value = raw.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(value)) {
+    return true;
+  }
+  if (["0", "false", "no", "off", ""].includes(value)) {
+    return false;
+  }
+  throw new Error(
+    `Invalid ${name} value \"${raw}\". Use one of: true/false, 1/0, yes/no, on/off.`
+  );
+};
+
+const getMonoEnabledProvidersFromEnv = () => {
+  const codexEnabled = parseMonoEnableEnv("VIBE80_MONO_ENABLE_CODEX");
+  const claudeEnabled = parseMonoEnableEnv("VIBE80_MONO_ENABLE_CLAUDE");
+  if (!codexEnabled && !claudeEnabled) {
+    throw new Error(
+      "In mono_user mode, enable at least one provider via --codex/--claude or VIBE80_MONO_ENABLE_CODEX/VIBE80_MONO_ENABLE_CLAUDE."
+    );
+  }
+  return { codexEnabled, claudeEnabled };
+};
+
+const applyMonoEnabledProviders = (providers = {}, enabledConfig) => {
+  const { codexEnabled, claudeEnabled } = enabledConfig;
+  const codexPrev = providers?.codex && typeof providers.codex === "object" ? providers.codex : {};
+  const claudePrev = providers?.claude && typeof providers.claude === "object" ? providers.claude : {};
+  return {
+    ...providers,
+    codex: {
+      enabled: Boolean(codexEnabled),
+      auth: codexPrev.auth || null,
+    },
+    claude: {
+      enabled: Boolean(claudeEnabled),
+      auth: claudePrev.auth || null,
+    },
+  };
+};
+
 const buildMonoUserProviderOverridesFromEnv = () => {
   const codexApiKey = readEnvValue("CODEX_API_KEY");
   const codexAuthJsonB64Raw = process.env.CODEX_AUTH_JSON_B64;
@@ -814,7 +869,6 @@ const buildMonoUserProviderOverridesFromEnv = () => {
         const decoded = decodeBase64(codexAuthJsonB64);
         validateCodexAuthJson(decoded);
         overrides.codex = {
-          enabled: true,
           auth: { type: "auth_json_b64", value: codexAuthJsonB64 },
         };
       } catch {
@@ -825,7 +879,6 @@ const buildMonoUserProviderOverridesFromEnv = () => {
     }
   } else if (codexApiKey) {
     overrides.codex = {
-      enabled: true,
       auth: { type: "api_key", value: codexApiKey },
     };
   }
@@ -842,13 +895,11 @@ const buildMonoUserProviderOverridesFromEnv = () => {
       );
     } else {
       overrides.claude = {
-        enabled: true,
         auth: { type: "setup_token", value: claudeSetupToken },
       };
     }
   } else if (claudeApiKey) {
     overrides.claude = {
-      enabled: true,
       auth: { type: "api_key", value: claudeApiKey },
     };
   }
@@ -869,7 +920,25 @@ export const applyMonoUserProviderOverridesFromEnv = async () => {
   if (!existing) {
     return;
   }
-  const mergedProviders = mergeProvidersForUpdate(existing.providers || {}, overrides);
+  const activationConfig = getMonoEnabledProvidersFromEnv();
+  const mergedProviders = mergeProvidersForUpdate(existing.providers || {}, {
+    ...(overrides.codex
+      ? {
+          codex: {
+            enabled: activationConfig.codexEnabled,
+            auth: overrides.codex.auth,
+          },
+        }
+      : {}),
+    ...(overrides.claude
+      ? {
+          claude: {
+            enabled: activationConfig.claudeEnabled,
+            auth: overrides.claude.auth,
+          },
+        }
+      : {}),
+  });
   const ids = await getWorkspaceUserIds(workspaceId);
   await writeWorkspaceProviderAuth(workspaceId, mergedProviders);
   await persistWorkspaceRecord({
@@ -891,13 +960,18 @@ export const createWorkspace = async (providers) => {
   if (isMonoUser) {
     const workspaceId = "default";
     await ensureWorkspaceDirs(workspaceId);
+    const enabledProviders = getMonoEnabledProvidersFromEnv();
     const secret = "default";
     const ids = await getWorkspaceUserIds(workspaceId);
     const existing = await storage.getWorkspace(workspaceId);
-    await writeWorkspaceProviderAuth(workspaceId, providers);
+    const providersWithActivation = applyMonoEnabledProviders(
+      providers || existing?.providers || {},
+      enabledProviders
+    );
+    await writeWorkspaceProviderAuth(workspaceId, providersWithActivation);
     await persistWorkspaceRecord({
       workspaceId,
-      providers,
+      providers: providersWithActivation,
       ids,
       workspaceSecretHash: hashWorkspaceSecret(secret),
       existing,