u-foo 1.4.1 → 1.6.0

package/src/chat/agentBar.js

@@ -1,5 +1,16 @@
 const { stripAnsi, truncateAnsi } = require("./text");
 
+const ACTIVITY_INDICATORS = {
+  working: "*",
+  waiting_input: "?",
+  blocked: "!",
+};
+
+const ACTIVITY_COLORS = {
+  waiting_input: "\x1b[33m", // yellow
+  blocked: "\x1b[31m",       // red
+};
+
 function computeAgentBar(options = {}) {
   const {
     cols = 80,
@@ -11,6 +22,7 @@ function computeAgentBar(options = {}) {
     agentListWindowStart = 0,
     maxAgentWindow = 4,
     getAgentLabel = (id) => id,
+    agentStates = {},
   } = options;
 
   const hintAnsi = `\x1b[90m│ ${hintText}\x1b[0m`;
@@ -60,12 +72,18 @@ function computeAgentBar(options = {}) {
       agentParts = visible.map((agent, i) => {
         const rawLabel = getAgentLabel(agent);
         const label = maxLabelLen ? truncateLabel(rawLabel, maxLabelLen) : rawLabel;
+        const actState = agentStates[agent] || "";
+        const indicator = ACTIVITY_INDICATORS[actState] || "";
+        const indicatorColor = ACTIVITY_COLORS[actState] || "";
+        const prefix = indicator
+          ? `${indicatorColor}${indicator}\x1b[0m`
+          : "";
         const idx = s + i + 1; // +1 for ucode at index 0
         if (focusMode === "dashboard" && idx === selectedAgentIndex) {
-          return `\x1b[90;7m${label}\x1b[0m`;
+          return `${prefix}\x1b[90;7m${label}\x1b[0m`;
         }
-        if (agent === viewingAgent) return `\x1b[1;36m${label}\x1b[0m`;
-        return `\x1b[36m${label}\x1b[0m`;
+        if (agent === viewingAgent) return `${prefix}\x1b[1;36m${label}\x1b[0m`;
+        return `${prefix}\x1b[36m${label}\x1b[0m`;
       });
     }
     const agentsText = activeAgents.length > 0

package/src/chat/agentViewController.js

@@ -16,6 +16,7 @@ function createAgentViewController(options = {}) {
     getAgentListWindowStart = () => 0,
     setAgentListWindowStart = () => {},
     getAgentLabel = (id) => id,
+    getAgentStates = () => ({}),
     setDashboardView = () => {},
     setScreenGrabKeys = (value) => {
       if (screen) screen.grabKeys = Boolean(value);
@@ -79,6 +80,7 @@ function createAgentViewController(options = {}) {
       agentListWindowStart: getAgentListWindowStart(),
       maxAgentWindow,
       getAgentLabel,
+      agentStates: getAgentStates(),
     });
     setAgentListWindowStart(computed.windowStart);
     processStdout.write(`\x1b7\x1b[${rows};1H${computed.bar}\x1b8`);

package/src/chat/chatLogController.js

@@ -2,8 +2,8 @@ function createChatLogController(options = {}) {
   const {
     logBox,
     fsModule,
-    historyDir,
-    historyFile,
+    historyDir: historyDirOption,
+    historyFile: historyFileOption,
     now = () => new Date().toISOString(),
   } = options;
 
@@ -13,9 +13,11 @@ function createChatLogController(options = {}) {
   if (!fsModule) {
     throw new Error("createChatLogController requires fsModule");
   }
-  if (!historyDir || !historyFile) {
+  if (!historyDirOption || !historyFileOption) {
     throw new Error("createChatLogController requires historyDir/historyFile");
   }
+  let historyDir = historyDirOption;
+  let historyFile = historyFileOption;
 
   const SPACED_TYPES = new Set(["user", "reply", "bus", "dispatch", "error"]);
   let lastLogWasSpacer = false;
@@ -95,9 +97,28 @@ function createChatLogController(options = {}) {
           recordLog(item.type || "unknown", item.text, item.meta || {}, false);
         }
       }
-    } catch {
-      // Ignore missing/invalid history.
+    } catch (err) {
+      if (err && err.code === "ENOENT") {
+        return;
+      }
+      if (err && typeof console !== "undefined" && typeof console.warn === "function") {
+        console.warn(`chat history load failed (${historyFile}): ${err.message || err}`);
+      }
+    }
+  }
+
+  function setHistoryTarget(next = {}) {
+    if (!next.historyDir || !next.historyFile) {
+      throw new Error("setHistoryTarget requires historyDir/historyFile");
     }
+    historyDir = next.historyDir;
+    historyFile = next.historyFile;
+  }
+
+  function resetViewState() {
+    // Callers are expected to clear logBox separately; this only resets spacing trackers.
+    lastLogWasSpacer = false;
+    hasLoggedAny = false;
   }
 
   return {
@@ -107,6 +128,8 @@ function createChatLogController(options = {}) {
     logMessage,
     markStreamStart,
     loadHistory,
+    setHistoryTarget,
+    resetViewState,
   };
 }
 

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,19 +2,50 @@ const { IPC_REQUEST_TYPES } = require("../shared/eventContract");
 
 function createDaemonConnection(options = {}) {
   const {
-    connectClient,
+    connectClient: connectClientOption,
     handleMessage,
     queueStatusLine,
     resolveStatusLine,
     logMessage,
+    switchConnectionTimeoutMs = 18000,
   } = options;
 
+  let connectClient = connectClientOption;
   let client = null;
   let reconnectPromise = null;
   let exitRequested = false;
   let connectionLostNotified = false;
   const pendingRequests = [];
   const MAX_PENDING_REQUESTS = 50;
+  const STATUS_KEY_RECONNECT = "daemon-reconnect";
+  const STATUS_KEY_SWITCH = "daemon-switch";
+  const DEFAULT_SWITCH_TIMEOUT_MS = Number.isFinite(switchConnectionTimeoutMs)
+    && switchConnectionTimeoutMs > 0
+    ? Math.trunc(switchConnectionTimeoutMs)
+    : 18000;
+
+  function withTimeout(promiseLike, timeoutMs, timeoutMessage) {
+    const ms = Number.isFinite(timeoutMs) && timeoutMs > 0
+      ? Math.trunc(timeoutMs)
+      : DEFAULT_SWITCH_TIMEOUT_MS;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const err = new Error(timeoutMessage || `operation timed out after ${ms}ms`);
+        err.code = "UFOO_TIMEOUT";
+        reject(err);
+      }, ms);
+      if (typeof timer.unref === "function") {
+        timer.unref();
+      }
+      Promise.resolve(promiseLike).then((value) => {
+        clearTimeout(timer);
+        resolve(value);
+      }, (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+  }
 
   function enqueueRequest(req) {
     if (!req || req.type === IPC_REQUEST_TYPES.STATUS) return;
@@ -90,18 +121,18 @@ function createDaemonConnection(options = {}) {
     if (client && !client.destroyed) return true;
     if (exitRequested) return false;
     if (reconnectPromise) return reconnectPromise;
-    queueStatusLine("Reconnecting to daemon");
+    queueStatusLine("Reconnecting to daemon", { key: STATUS_KEY_RECONNECT });
     logMessage("status", "{white-fg}⚙{/white-fg} Reconnecting to daemon...");
     reconnectPromise = (async () => {
       const newClient = await connectClient();
       if (!newClient) {
-        resolveStatusLine("{gray-fg}✗{/gray-fg} Daemon offline");
+        resolveStatusLine("{gray-fg}✗{/gray-fg} Daemon offline", { key: STATUS_KEY_RECONNECT });
         logMessage("error", "{white-fg}✗{/white-fg} Failed to reconnect to daemon");
         return false;
       }
       attachClient(newClient);
       connectionLostNotified = false;
-      resolveStatusLine("{gray-fg}✓{/gray-fg} Daemon reconnected");
+      resolveStatusLine("{gray-fg}✓{/gray-fg} Daemon reconnected", { key: STATUS_KEY_RECONNECT });
       requestStatus();
       return true;
     })();
@@ -120,6 +151,47 @@ 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", { key: STATUS_KEY_SWITCH });
+      const timeoutMs = Number.isFinite(next.timeoutMs) && next.timeoutMs > 0
+        ? Math.trunc(next.timeoutMs)
+        : DEFAULT_SWITCH_TIMEOUT_MS;
+      const nextClient = await withTimeout(
+        nextConnectClient(),
+        timeoutMs,
+        `Switch connection timed out after ${timeoutMs}ms`
+      );
+      if (!nextClient) {
+        resolveStatusLine("{gray-fg}✗{/gray-fg} Switch failed", { key: STATUS_KEY_SWITCH });
+        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", { key: STATUS_KEY_SWITCH });
+      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", { key: STATUS_KEY_SWITCH });
+      logMessage("error", `{white-fg}✗{/white-fg} ${message}`);
+      return { ok: false, error: message };
+    }
+  }
+
   function send(req) {
     if (!client || client.destroyed) {
       enqueueRequest(req);
@@ -155,6 +227,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/daemonMessageRouter.js

@@ -25,8 +25,17 @@ function createDaemonMessageRouter(options = {}) {
     appendStreamDelta = () => {},
     finalizeStream = () => {},
     hasStream = () => false,
+    setTransientAgentState = () => {},
+    clearTransientAgentState = () => {},
+    refreshDashboard = () => {},
   } = options;
 
+  function isLikelySubscriberId(value) {
+    const text = String(value || "");
+    if (!text) return false;
+    return text.includes(":") && !text.includes(" ");
+  }
+
   function normalizeDisplayMessage(raw) {
     let displayMessage = raw || "";
     let streamPayload = null;
@@ -53,6 +62,14 @@ function createDaemonMessageRouter(options = {}) {
     if (typeof data.phase === "string") {
       const text = data.text || "";
       const item = { key: data.key, text };
+      const key = typeof data.key === "string" ? data.key : "";
+      if (isLikelySubscriberId(key)) {
+        if (data.phase === BUS_STATUS_PHASES.START) {
+          setTransientAgentState(key, "working");
+        } else if (data.phase === BUS_STATUS_PHASES.DONE || data.phase === BUS_STATUS_PHASES.ERROR) {
+          clearTransientAgentState(key);
+        }
+      }
       if (data.phase === BUS_STATUS_PHASES.START) {
         enqueueBusStatus(item);
       } else if (data.phase === BUS_STATUS_PHASES.DONE || data.phase === BUS_STATUS_PHASES.ERROR) {
@@ -66,6 +83,7 @@ function createDaemonMessageRouter(options = {}) {
       } else {
         enqueueBusStatus(item);
       }
+      refreshDashboard();
       renderScreen();
       return false;
     }
@@ -301,6 +319,10 @@ function createDaemonMessageRouter(options = {}) {
 
   function handleBusMessage(msg) {
     const data = msg.data || {};
+    if (data.event === "activity_state_changed") {
+      requestStatus();
+      return true;
+    }
     const prefix = data.event === "broadcast" ? "{gray-fg}⇢{/gray-fg}" : "{gray-fg}↔{/gray-fg}";
     const publisher = data.publisher && data.publisher !== "unknown"
       ? data.publisher

package/src/chat/daemonTransport.js

@@ -11,23 +11,65 @@ function createDaemonTransport(options = {}) {
     secondaryRetries = DAEMON_TRANSPORT_DEFAULTS.secondaryRetries,
     retryDelayMs = DAEMON_TRANSPORT_DEFAULTS.retryDelayMs,
     restartDelayMs = DAEMON_TRANSPORT_DEFAULTS.restartDelayMs,
+    connectTimeoutMs = DAEMON_TRANSPORT_DEFAULTS.connectTimeoutMs,
   } = 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,
+      { timeoutMs: connectTimeoutMs }
+    );
     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,
+        { timeoutMs: connectTimeoutMs }
+      );
     }
     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/daemonTransportDefaults.js

@@ -3,6 +3,7 @@ const DAEMON_TRANSPORT_DEFAULTS = {
   secondaryRetries: 50,
   retryDelayMs: 200,
   restartDelayMs: 1000,
+  connectTimeoutMs: 2000,
 };
 
 module.exports = {