u-foo 1.4.1 → 1.5.0

package/src/chat/commandExecutor.js

@@ -22,6 +22,13 @@ function defaultCreateSkills(projectRoot) {
   return new UfooSkills(projectRoot);
 }
 
+function defaultResolveTerminalApp() {
+  const program = String(process.env.TERM_PROGRAM || "").trim();
+  if (program === "Apple_Terminal") return "terminal";
+  if (program === "iTerm.app" || process.env.ITERM_SESSION_ID) return "iterm2";
+  return "";
+}
+
 async function withCapturedConsole(capture, fn) {
   const originalLog = console.log;
   const originalError = console.error;
@@ -72,6 +79,10 @@ function createCommandExecutor(options = {}) {
     stopCronTask = () => false,
     runGroupCore = runGroupCoreCommand,
     requestCron = null,
+    listProjects = () => [],
+    getCurrentProject = () => ({ projectRoot }),
+    switchProject = async () => ({ ok: false, error: "project switching unavailable" }),
+    resolveTerminalApp = defaultResolveTerminalApp,
     sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
     schedule = (fn, ms) => setTimeout(fn, ms),
   } = options;
@@ -355,7 +366,10 @@ function createCommandExecutor(options = {}) {
 
   async function handleLaunchCommand(args = []) {
     if (args.length === 0) {
-      logMessage("error", "{white-fg}✗{/white-fg} Usage: /launch <claude|codex|ucode> [nickname=<name>] [count=<n>]");
+      logMessage(
+        "error",
+        "{white-fg}✗{/white-fg} Usage: /launch <claude|codex|ucode> [nickname=<name>] [count=<n>] [scope=inplace|window]"
+      );
       return;
     }
 
@@ -375,20 +389,68 @@ function createCommandExecutor(options = {}) {
       }
     }
 
+    function normalizeLaunchScopeOption(value, fallback = "inplace") {
+      const raw = String(value || "").trim().toLowerCase();
+      if (!raw) return fallback;
+      if (raw === "inplace" || raw === "same" || raw === "current" || raw === "tab" || raw === "pane") {
+        return "inplace";
+      }
+      if (
+        raw === "window"
+        || raw === "separate"
+        || raw === "new"
+        || raw === "new-window"
+        || raw === "external"
+        || raw === "1"
+        || raw === "true"
+        || raw === "yes"
+        || raw === "y"
+        || raw === "on"
+      ) {
+        return "window";
+      }
+      if (raw === "0" || raw === "false" || raw === "no" || raw === "n" || raw === "off") {
+        return "inplace";
+      }
+      return "";
+    }
+
     const nickname = parsedOptions.nickname || "";
     const count = parseInt(parsedOptions.count || "1", 10);
+    const scopeRaw = parsedOptions.scope || parsedOptions.launch_scope || parsedOptions.window || "";
+    let launchScope = normalizeLaunchScopeOption(scopeRaw, "inplace");
+    if (scopeRaw && !launchScope) {
+      logMessage("error", "{white-fg}✗{/white-fg} scope must be inplace|window");
+      return;
+    }
+    const rawFlags = args
+      .slice(1)
+      .filter((arg) => !String(arg || "").includes("="))
+      .map((arg) => String(arg || "").trim().toLowerCase())
+      .filter(Boolean);
+    for (const flag of rawFlags) {
+      const normalized = normalizeLaunchScopeOption(flag, "");
+      if (normalized) launchScope = normalized;
+    }
+    if (!launchScope) launchScope = "inplace";
     if (nickname && count > 1) {
       logMessage("error", "{white-fg}✗{/white-fg} nickname requires count=1");
       return;
     }
 
     try {
-      send({
+      const request = {
         type: IPC_REQUEST_TYPES.LAUNCH_AGENT,
         agent: normalizedAgent,
         count: Number.isFinite(count) ? count : 1,
         nickname,
-      });
+        launch_scope: launchScope,
+      };
+      const terminalApp = String(resolveTerminalApp() || "").trim().toLowerCase();
+      if (terminalApp === "terminal" || terminalApp === "iterm2") {
+        request.terminal_app = terminalApp;
+      }
+      send(request);
       schedule(requestStatus, 1000);
     } catch (err) {
       logMessage("error", `{white-fg}✗{/white-fg} Launch failed: ${escapeBlessed(err.message)}`);
@@ -413,6 +475,64 @@ function createCommandExecutor(options = {}) {
     schedule(requestStatus, 1000);
   }
 
+  async function handleProjectCommand(args = []) {
+    const subcommand = String(args[0] || "list").trim().toLowerCase();
+
+    if (subcommand === "list") {
+      const rowsRaw = await Promise.resolve(listProjects());
+      const rows = Array.isArray(rowsRaw) ? rowsRaw : [];
+      const current = await Promise.resolve(getCurrentProject());
+      const currentRoot = current && current.project_root ? String(current.project_root) : "";
+      if (rows.length === 0) {
+        logMessage("system", "{white-fg}No projects found{/white-fg}");
+        return;
+      }
+      logMessage("system", `{cyan-fg}Projects:{/cyan-fg} ${rows.length}`);
+      rows.forEach((item, idx) => {
+        const row = item || {};
+        const root = String(row.project_root || "");
+        const name = String(row.project_name || root || "-");
+        const status = String(row.status || "unknown");
+        const marker = root && root === currentRoot ? "*" : " ";
+        logMessage(
+          "system",
+          `${marker}${idx + 1}. {cyan-fg}${escapeBlessed(name)}{/cyan-fg} [{white-fg}${escapeBlessed(status)}{/white-fg}] ${escapeBlessed(root)}`
+        );
+      });
+      return;
+    }
+
+    if (subcommand === "current") {
+      const current = await Promise.resolve(getCurrentProject());
+      if (!current || !current.project_root) {
+        logMessage("error", "{white-fg}✗{/white-fg} Current project unavailable");
+        return;
+      }
+      logMessage("system", `{cyan-fg}Current:{/cyan-fg} ${escapeBlessed(current.project_root)}`);
+      return;
+    }
+
+    if (subcommand === "switch") {
+      const target = String(args[1] || "").trim();
+      if (!target) {
+        logMessage("error", "{white-fg}✗{/white-fg} Usage: /project switch <index|path>");
+        return;
+      }
+      logMessage("system", `{white-fg}⚙{/white-fg} Switching project: ${escapeBlessed(target)}`);
+      const result = await Promise.resolve(switchProject({ target }));
+      if (!result || result.ok !== true) {
+        const reason = result && result.error ? String(result.error) : "switch failed";
+        logMessage("error", `{white-fg}✗{/white-fg} Switch failed: ${escapeBlessed(reason)}`);
+        return;
+      }
+      const nextRoot = result.project_root || result.projectRoot || "";
+      logMessage("system", `{white-fg}✓{/white-fg} Switched project: ${escapeBlessed(nextRoot)}`);
+      return;
+    }
+
+    logMessage("error", "{white-fg}✗{/white-fg} Unknown project command. Use: list, current, switch");
+  }
+
   function parseKeyValueArgs(args = []) {
     const parsed = {};
     for (const raw of args) {
@@ -963,6 +1083,9 @@ function createCommandExecutor(options = {}) {
       case "resume":
         await handleResumeCommand(args);
         return true;
+      case "project":
+        await handleProjectCommand(args);
+        return true;
       case "cron":
         await handleCronCommand(args);
         return true;
@@ -992,6 +1115,7 @@ function createCommandExecutor(options = {}) {
     handleSkillsCommand,
     handleLaunchCommand,
     handleResumeCommand,
+    handleProjectCommand,
     handleCronCommand,
     handleGroupCommand,
     handleSettingsCommand,

package/src/chat/commands.js

@@ -55,6 +55,14 @@ const COMMAND_TREE = {
       ucode: { desc: "Launch ucode core agent" },
     },
   },
+  "/project": {
+    desc: "Project switch operations (spike)",
+    children: {
+      current: { desc: "Show current chat project" },
+      list: { desc: "List running projects from registry" },
+      switch: { desc: "Switch daemon connection to project index/path" },
+    },
+  },
   "/resume": {
     desc: "Resume agents (optional nickname) or list recoverable targets",
     children: {

package/src/chat/daemonConnection.js

@@ -2,13 +2,14 @@ const { IPC_REQUEST_TYPES } = require("../shared/eventContract");
 
 function createDaemonConnection(options = {}) {
   const {
-    connectClient,
+    connectClient: connectClientOption,
     handleMessage,
     queueStatusLine,
     resolveStatusLine,
     logMessage,
   } = options;
 
+  let connectClient = connectClientOption;
   let client = null;
   let reconnectPromise = null;
   let exitRequested = false;
@@ -120,6 +121,39 @@ function createDaemonConnection(options = {}) {
     return true;
   }
 
+  async function switchConnection(next = {}) {
+    const nextConnectClient = typeof next.connectClient === "function"
+      ? next.connectClient
+      : null;
+    if (!nextConnectClient) {
+      return { ok: false, error: "switchConnection requires connectClient" };
+    }
+    const previousClient = client;
+    try {
+      queueStatusLine("Switching daemon connection");
+      const nextClient = await nextConnectClient();
+      if (!nextClient) {
+        return { ok: false, error: "Failed to connect target daemon" };
+      }
+      connectClient = nextConnectClient;
+      attachClient(nextClient);
+      if (next.callRequestStatus !== false) {
+        requestStatus();
+      }
+      resolveStatusLine("{gray-fg}✓{/gray-fg} Daemon switched");
+      return { ok: true };
+    } catch (err) {
+      // Keep existing connection alive on switch failures.
+      if (previousClient && (!client || client.destroyed)) {
+        client = previousClient;
+      }
+      const message = err && err.message ? err.message : String(err || "switch failed");
+      resolveStatusLine("{gray-fg}✗{/gray-fg} Switch failed");
+      logMessage("error", `{white-fg}✗{/white-fg} ${message}`);
+      return { ok: false, error: message };
+    }
+  }
+
   function send(req) {
     if (!client || client.destroyed) {
       enqueueRequest(req);
@@ -155,6 +189,7 @@ function createDaemonConnection(options = {}) {
     connect,
     send,
     requestStatus,
+    switchConnection,
     close,
     markExit,
     getState,

package/src/chat/daemonCoordinator.js

@@ -40,6 +40,41 @@ function createDaemonCoordinator(options = {}) {
     daemonConnection: connection,
     logMessage,
   });
+  let switchProjectChain = Promise.resolve();
+
+  function switchProject(target = {}) {
+    const runSwitch = async () => {
+      if (!daemonTransport || typeof daemonTransport.connectClientForTarget !== "function") {
+        return { ok: false, error: "project switching requires daemonTransport.connectClientForTarget" };
+      }
+      if (!target || !target.projectRoot || !target.sockPath) {
+        return { ok: false, error: "switchProject requires projectRoot and sockPath" };
+      }
+      if (!connection || typeof connection.switchConnection !== "function") {
+        return { ok: false, error: "daemon connection does not support switching" };
+      }
+
+      const result = await connection.switchConnection({
+        connectClient: () => daemonTransport.connectClientForTarget(target),
+        callRequestStatus: false,
+      });
+      if (!result || result.ok !== true) {
+        return {
+          ok: false,
+          error: (result && result.error) || "switch failed",
+        };
+      }
+      if (typeof daemonTransport.setTarget === "function") {
+        daemonTransport.setTarget(target);
+      }
+      connection.requestStatus();
+      return { ok: true, target };
+    };
+
+    const scheduled = switchProjectChain.then(runSwitch, runSwitch);
+    switchProjectChain = scheduled.catch(() => {});
+    return scheduled;
+  }
 
   function isConnected() {
     if (!connection || typeof connection.getState !== "function") return false;
@@ -54,6 +89,7 @@ function createDaemonCoordinator(options = {}) {
     restart: () => restart(),
     close: () => connection.close(),
     markExit: () => connection.markExit(),
+    switchProject,
     isConnected,
     getState: () => (typeof connection.getState === "function" ? connection.getState() : null),
   };

package/src/chat/daemonTransport.js

@@ -13,21 +13,52 @@ function createDaemonTransport(options = {}) {
     restartDelayMs = DAEMON_TRANSPORT_DEFAULTS.restartDelayMs,
   } = options;
 
-  async function connectClient() {
-    let client = await connectWithRetry(sockPath, primaryRetries, retryDelayMs);
+  let activeProjectRoot = projectRoot;
+  let activeSockPath = sockPath;
+
+  function resolveTarget(override = {}) {
+    return {
+      projectRoot: override.projectRoot || activeProjectRoot,
+      sockPath: override.sockPath || activeSockPath,
+    };
+  }
+
+  async function connectClientForTarget(override = {}) {
+    const target = resolveTarget(override);
+    let client = await connectWithRetry(target.sockPath, primaryRetries, retryDelayMs);
     if (!client) {
       // Retry once with a fresh daemon start and longer wait.
-      if (!isRunning(projectRoot)) {
-        startDaemon(projectRoot);
+      if (!isRunning(target.projectRoot)) {
+        startDaemon(target.projectRoot);
         await new Promise((resolve) => setTimeout(resolve, restartDelayMs));
       }
-      client = await connectWithRetry(sockPath, secondaryRetries, retryDelayMs);
+      client = await connectWithRetry(target.sockPath, secondaryRetries, retryDelayMs);
     }
     return client;
   }
 
+  async function connectClient() {
+    return connectClientForTarget();
+  }
+
+  function setTarget(next = {}) {
+    if (next.projectRoot) activeProjectRoot = next.projectRoot;
+    if (next.sockPath) activeSockPath = next.sockPath;
+    return getTarget();
+  }
+
+  function getTarget() {
+    return {
+      projectRoot: activeProjectRoot,
+      sockPath: activeSockPath,
+    };
+  }
+
   return {
     connectClient,
+    connectClientForTarget,
+    setTarget,
+    getTarget,
   };
 }
 

package/src/chat/dashboardKeyController.js

@@ -3,6 +3,7 @@ const DEFAULT_MODE_OPTIONS = ["terminal", "tmux", "internal"];
 function createDashboardKeyController(options = {}) {
   const {
     state,
+    globalMode = false,
     existsSync = () => false,
     getInjectSockPath = () => "",
     getAgentAdapter = () => null,
@@ -21,6 +22,7 @@ function createDashboardKeyController(options = {}) {
     setAutoResume = () => {},
     clampAgentWindow = () => {},
     clampAgentWindowWithSelection = () => {},
+    requestProjectSwitch = () => {},
     renderDashboard = () => {},
     renderAgentDashboard = () => {},
     renderScreen = () => {},
@@ -374,6 +376,65 @@ function createDashboardKeyController(options = {}) {
     return true;
   }
 
+  function handleProjectsKey(key) {
+    const projects = Array.isArray(state.projects) ? state.projects : [];
+    if (projects.length === 0) {
+      if (key.name === "up" || key.name === "enter" || key.name === "return" || key.name === "escape") {
+        exitDashboardMode(false);
+      }
+      return true;
+    }
+
+    if (key.name === "down") {
+      state.dashboardView = "agents";
+      if (!Array.isArray(state.activeAgents) || state.activeAgents.length === 0) {
+        state.selectedAgentIndex = -1;
+      } else if (!Number.isFinite(state.selectedAgentIndex) || state.selectedAgentIndex < 0) {
+        state.selectedAgentIndex = 0;
+      } else if (state.selectedAgentIndex >= state.activeAgents.length) {
+        state.selectedAgentIndex = state.activeAgents.length - 1;
+      }
+      clampAgentWindow();
+      syncTargetFromSelection();
+      renderDashboardAndScreen();
+      return true;
+    }
+
+    if (key.name === "left") {
+      const current = Number.isFinite(state.selectedProjectIndex) ? state.selectedProjectIndex : 0;
+      if (current > 0) {
+        const next = current - 1;
+        state.selectedProjectIndex = next;
+        renderDashboardAndScreen();
+        requestProjectSwitch(next);
+      }
+      return true;
+    }
+
+    if (key.name === "right") {
+      const current = Number.isFinite(state.selectedProjectIndex) ? state.selectedProjectIndex : 0;
+      if (current < projects.length - 1) {
+        const next = current + 1;
+        state.selectedProjectIndex = next;
+        renderDashboardAndScreen();
+        requestProjectSwitch(next);
+      }
+      return true;
+    }
+
+    if (key.name === "up" || key.name === "escape") {
+      exitDashboardMode(false);
+      return true;
+    }
+
+    if (key.name === "enter" || key.name === "return") {
+      exitDashboardMode(false);
+      return true;
+    }
+
+    return true;
+  }
+
   function handleAgentsKey(key) {
     if (key.name === "left") {
       if (state.activeAgents.length > 0 && state.selectedAgentIndex > 0) {
@@ -403,7 +464,18 @@ function createDashboardKeyController(options = {}) {
       return true;
     }
 
-    if (key.name === "up" || key.name === "escape") {
+    if (key.name === "up") {
+      clearTargetAgent();
+      if (globalMode) {
+        state.dashboardView = "projects";
+        renderDashboardAndScreen();
+        return true;
+      }
+      exitDashboardMode(false);
+      return true;
+    }
+
+    if (key.name === "escape") {
       clearTargetAgent();
       exitDashboardMode(false);
       return true;
@@ -461,6 +533,13 @@ function createDashboardKeyController(options = {}) {
       return handleAgentDashboardKey(key);
     }
 
+    if (globalMode && state.dashboardView === "projects") {
+      return handleProjectsKey(key);
+    }
+    if (!globalMode && state.dashboardView === "projects") {
+      return true;
+    }
+
     if (state.dashboardView === "mode") return handleModeKey(key);
     if (state.dashboardView === "provider") return handleProviderKey(key);
     if (state.dashboardView === "assistant") return handleAssistantKey(key);