@tiflis-io/tiflis-code-workstation 0.3.3 → 0.3.5

package/dist/main.js

@@ -347,6 +347,22 @@ var AGENT_EXECUTION_CONFIG = {
   ]
 };
 var BASE_AGENT_TYPES = ["cursor", "claude", "opencode"];
+function isBaseAgentDisabled(baseType) {
+  const env = getEnv();
+  switch (baseType) {
+    case "cursor":
+      return env.HIDE_BASE_CURSOR;
+    case "claude":
+      return env.HIDE_BASE_CLAUDE;
+    case "opencode":
+      return env.HIDE_BASE_OPENCODE;
+    default:
+      return false;
+  }
+}
+function getDisabledBaseAgents() {
+  return BASE_AGENT_TYPES.filter(isBaseAgentDisabled);
+}
 function getBaseTypeFromCommand(command) {
   const commandMap = {
     claude: "claude",
@@ -357,33 +373,39 @@ function getBaseTypeFromCommand(command) {
 }
 function getAvailableAgents() {
   const agents = /* @__PURE__ */ new Map();
-  agents.set("cursor", {
-    name: "cursor",
-    command: AGENT_COMMANDS.cursor.command,
-    aliasArgs: [],
-    aliasEnvVars: {},
-    baseType: "cursor",
-    description: AGENT_COMMANDS.cursor.description,
-    isAlias: false
-  });
-  agents.set("claude", {
-    name: "claude",
-    command: AGENT_COMMANDS.claude.command,
-    aliasArgs: [],
-    aliasEnvVars: {},
-    baseType: "claude",
-    description: AGENT_COMMANDS.claude.description,
-    isAlias: false
-  });
-  agents.set("opencode", {
-    name: "opencode",
-    command: AGENT_COMMANDS.opencode.command,
-    aliasArgs: [],
-    aliasEnvVars: {},
-    baseType: "opencode",
-    description: AGENT_COMMANDS.opencode.description,
-    isAlias: false
-  });
+  if (!isBaseAgentDisabled("cursor")) {
+    agents.set("cursor", {
+      name: "cursor",
+      command: AGENT_COMMANDS.cursor.command,
+      aliasArgs: [],
+      aliasEnvVars: {},
+      baseType: "cursor",
+      description: AGENT_COMMANDS.cursor.description,
+      isAlias: false
+    });
+  }
+  if (!isBaseAgentDisabled("claude")) {
+    agents.set("claude", {
+      name: "claude",
+      command: AGENT_COMMANDS.claude.command,
+      aliasArgs: [],
+      aliasEnvVars: {},
+      baseType: "claude",
+      description: AGENT_COMMANDS.claude.description,
+      isAlias: false
+    });
+  }
+  if (!isBaseAgentDisabled("opencode")) {
+    agents.set("opencode", {
+      name: "opencode",
+      command: AGENT_COMMANDS.opencode.command,
+      aliasArgs: [],
+      aliasEnvVars: {},
+      baseType: "opencode",
+      description: AGENT_COMMANDS.opencode.description,
+      isAlias: false
+    });
+  }
   const aliases = getAgentAliases();
   for (const [name, alias] of aliases) {
     const baseType = getBaseTypeFromCommand(alias.baseCommand);
@@ -1102,8 +1124,21 @@ var HeartbeatSchema = z2.object({
 var SyncMessageSchema = z2.object({
   type: z2.literal("sync"),
   id: z2.string(),
-  device_id: z2.string().optional()
+  device_id: z2.string().optional(),
+  // Injected by tunnel for tunnel connections
+  lightweight: z2.boolean().optional()
+  // If true, excludes message histories (for watchOS)
+});
+var HistoryRequestPayloadSchema = z2.object({
+  session_id: z2.string().optional()
+  // If omitted, returns supervisor history
+});
+var HistoryRequestSchema = z2.object({
+  type: z2.literal("history.request"),
+  id: z2.string(),
+  device_id: z2.string().optional(),
   // Injected by tunnel for tunnel connections
+  payload: HistoryRequestPayloadSchema.optional()
 });
 var ListSessionsSchema = z2.object({
   type: z2.literal("supervisor.list_sessions"),
@@ -1260,6 +1295,7 @@ var IncomingClientMessageSchema = z2.discriminatedUnion("type", [
   PingSchema,
   HeartbeatSchema,
   SyncMessageSchema,
+  HistoryRequestSchema,
   ListSessionsSchema,
   CreateSessionSchema,
   TerminateSessionSchema,
@@ -7355,10 +7391,11 @@ async function bootstrap() {
       const syncMessage = message;
       const client = clientRegistry.getBySocket(socket) ?? (syncMessage.device_id ? clientRegistry.getByDeviceId(new DeviceId(syncMessage.device_id)) : void 0);
       const subscriptions2 = client ? client.getSubscriptions() : [];
+      const isLightweight = syncMessage.lightweight === true;
       const inMemorySessions = sessionManager.getSessionInfos();
       const persistedAgentSessions = chatHistoryService.getActiveAgentSessions();
       logger.debug(
-        { persistedAgentSessions, inMemoryCount: inMemorySessions.length },
+        { persistedAgentSessions, inMemoryCount: inMemorySessions.length, isLightweight },
         "Sync: fetched sessions"
       );
       const inMemorySessionIds = new Set(
@@ -7383,6 +7420,67 @@ async function bootstrap() {
         };
       });
       const sessions2 = [...inMemorySessions, ...restoredAgentSessions];
+      if (isLightweight) {
+        const availableAgentsMap2 = getAvailableAgents();
+        const availableAgents2 = Array.from(availableAgentsMap2.values()).map(
+          (agent) => ({
+            name: agent.name,
+            base_type: agent.baseType,
+            description: agent.description,
+            is_alias: agent.isAlias
+          })
+        );
+        const hiddenBaseTypes2 = getDisabledBaseAgents();
+        const workspacesList2 = await workspaceDiscovery.listWorkspaces();
+        const workspaces2 = await Promise.all(
+          workspacesList2.map(async (ws) => {
+            const projects = await workspaceDiscovery.listProjects(ws.name);
+            return {
+              name: ws.name,
+              projects: projects.map((p) => ({
+                name: p.name,
+                is_git_repo: p.isGitRepo,
+                default_branch: p.defaultBranch
+              }))
+            };
+          })
+        );
+        const executingStates2 = {};
+        for (const session of sessions2) {
+          if (session.session_type === "cursor" || session.session_type === "claude" || session.session_type === "opencode") {
+            executingStates2[session.session_id] = agentSessionManager.isExecuting(
+              session.session_id
+            );
+          }
+        }
+        const supervisorIsExecuting2 = supervisorAgent.isProcessing();
+        logger.info(
+          {
+            totalSessions: sessions2.length,
+            isLightweight: true,
+            availableAgentsCount: availableAgents2.length,
+            workspacesCount: workspaces2.length,
+            supervisorIsExecuting: supervisorIsExecuting2
+          },
+          "Sync: sending lightweight state to client (no histories)"
+        );
+        const syncStateMessage2 = JSON.stringify({
+          type: "sync.state",
+          id: syncMessage.id,
+          payload: {
+            sessions: sessions2,
+            subscriptions: subscriptions2,
+            availableAgents: availableAgents2,
+            hiddenBaseTypes: hiddenBaseTypes2,
+            workspaces: workspaces2,
+            supervisorIsExecuting: supervisorIsExecuting2,
+            executingStates: executingStates2
+            // Omit: supervisorHistory, agentHistories, currentStreamingBlocks
+          }
+        });
+        sendToDevice(socket, syncMessage.device_id, syncStateMessage2);
+        return Promise.resolve();
+      }
       const supervisorHistoryRaw = chatHistoryService.getSupervisorHistory();
       const supervisorHistory = await Promise.all(
         supervisorHistoryRaw.map(async (msg) => ({
@@ -7437,16 +7535,7 @@ async function bootstrap() {
           is_alias: agent.isAlias
         })
       );
-      const hiddenBaseTypes = [];
-      if (env.HIDE_BASE_CURSOR) {
-        hiddenBaseTypes.push("cursor");
-      }
-      if (env.HIDE_BASE_CLAUDE) {
-        hiddenBaseTypes.push("claude");
-      }
-      if (env.HIDE_BASE_OPENCODE) {
-        hiddenBaseTypes.push("opencode");
-      }
+      const hiddenBaseTypes = getDisabledBaseAgents();
       const workspacesList = await workspaceDiscovery.listWorkspaces();
       const workspaces = await Promise.all(
         workspacesList.map(async (ws) => {
@@ -8498,6 +8587,107 @@ async function bootstrap() {
       }
       return Promise.resolve();
     },
+    "history.request": async (socket, message) => {
+      const historyRequest = message;
+      const sessionId = historyRequest.payload?.session_id;
+      const isSupervisor = !sessionId;
+      logger.debug(
+        { sessionId, isSupervisor, requestId: historyRequest.id },
+        "History request received"
+      );
+      try {
+        if (isSupervisor) {
+          const supervisorHistoryRaw = chatHistoryService.getSupervisorHistory();
+          const supervisorHistory = await Promise.all(
+            supervisorHistoryRaw.map(async (msg) => ({
+              message_id: msg.id,
+              // Include message ID for audio.request
+              sequence: msg.sequence,
+              role: msg.role,
+              content: msg.content,
+              content_blocks: await chatHistoryService.enrichBlocksWithAudio(
+                msg.contentBlocks,
+                msg.audioOutputPath,
+                msg.audioInputPath,
+                false
+                // Don't include audio in history response
+              ),
+              createdAt: msg.createdAt.toISOString()
+            }))
+          );
+          const isExecuting = supervisorAgent.isProcessing();
+          socket.send(
+            JSON.stringify({
+              type: "history.response",
+              id: historyRequest.id,
+              payload: {
+                session_id: null,
+                // Indicates supervisor
+                history: supervisorHistory,
+                is_executing: isExecuting
+              }
+            })
+          );
+          logger.debug(
+            { messageCount: supervisorHistory.length, isExecuting },
+            "Supervisor history sent"
+          );
+        } else {
+          const history = chatHistoryService.getAgentHistory(sessionId);
+          const enrichedHistory = await Promise.all(
+            history.map(async (msg) => ({
+              sequence: msg.sequence,
+              role: msg.role,
+              content: msg.content,
+              content_blocks: await chatHistoryService.enrichBlocksWithAudio(
+                msg.contentBlocks,
+                msg.audioOutputPath,
+                msg.audioInputPath,
+                false
+                // Don't include audio in history response
+              ),
+              createdAt: msg.createdAt.toISOString()
+            }))
+          );
+          const isExecuting = agentSessionManager.isExecuting(sessionId);
+          let currentStreamingBlocks;
+          if (isExecuting) {
+            const blocks = agentMessageAccumulator.get(sessionId);
+            if (blocks && blocks.length > 0) {
+              currentStreamingBlocks = blocks;
+            }
+          }
+          socket.send(
+            JSON.stringify({
+              type: "history.response",
+              id: historyRequest.id,
+              payload: {
+                session_id: sessionId,
+                history: enrichedHistory,
+                is_executing: isExecuting,
+                current_streaming_blocks: currentStreamingBlocks
+              }
+            })
+          );
+          logger.debug(
+            { sessionId, messageCount: enrichedHistory.length, isExecuting },
+            "Agent session history sent"
+          );
+        }
+      } catch (error) {
+        logger.error({ error, sessionId }, "Failed to get history");
+        socket.send(
+          JSON.stringify({
+            type: "history.response",
+            id: historyRequest.id,
+            payload: {
+              session_id: sessionId ?? null,
+              error: error instanceof Error ? error.message : "Failed to get history"
+            }
+          })
+        );
+      }
+    },
     "audio.request": async (socket, message) => {
       const audioRequest = message;
       const { message_id, type = "output" } = audioRequest.payload;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiflis-io/tiflis-code-workstation",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "Workstation server for tiflis-code - manages agent sessions and terminal access",
   "author": "Roman Barinov <rbarinov@gmail.com>",
   "license": "FSL-1.1-NC",