@hydra-acp/cli 0.1.40 → 0.1.42

package/dist/index.d.ts

@@ -1415,6 +1415,7 @@ declare const SessionListEntry: z.ZodObject<{
     updatedAt: z.ZodString;
     attachedClients: z.ZodNumber;
     status: z.ZodDefault<z.ZodEnum<["live", "cold"]>>;
+    busy: z.ZodDefault<z.ZodBoolean>;
     _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
     sessionId: string;
@@ -1422,6 +1423,7 @@ declare const SessionListEntry: z.ZodObject<{
     status: "live" | "cold";
     updatedAt: string;
     attachedClients: number;
+    busy: boolean;
     agentId?: string | undefined;
     upstreamSessionId?: string | undefined;
     title?: string | undefined;
@@ -1454,6 +1456,7 @@ declare const SessionListEntry: z.ZodObject<{
     } | undefined;
     importedFromMachine?: string | undefined;
     importedFromUpstreamSessionId?: string | undefined;
+    busy?: boolean | undefined;
 }>;
 type SessionListEntry = z.infer<typeof SessionListEntry>;
 declare const SessionListResult: z.ZodObject<{
@@ -1984,6 +1987,7 @@ declare const SessionRecord: z.ZodObject<{
         name?: string | undefined;
         description?: string | undefined;
     }>, "many">>;
+    pendingHistorySync: z.ZodOptional<z.ZodBoolean>;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
 }, "strip", z.ZodTypeAny, {
@@ -2022,6 +2026,7 @@ declare const SessionRecord: z.ZodObject<{
         name?: string | undefined;
         description?: string | undefined;
     }[] | undefined;
+    pendingHistorySync?: boolean | undefined;
 }, {
     sessionId: string;
     version: 1;
@@ -2058,6 +2063,7 @@ declare const SessionRecord: z.ZodObject<{
         name?: string | undefined;
         description?: string | undefined;
     }[] | undefined;
+    pendingHistorySync?: boolean | undefined;
 }>;
 type SessionRecord = z.infer<typeof SessionRecord>;
 declare class SessionStore {
@@ -2305,6 +2311,7 @@ interface ResurrectParams {
     agentModes?: AdvertisedMode[];
     agentModels?: AdvertisedModel[];
     createdAt?: string;
+    pendingHistorySync?: boolean;
 }
 type AgentSpawner = (opts: AgentInstanceOptions) => AgentInstance;
 interface SessionManagerOptions {
@@ -2333,11 +2340,17 @@ declare class SessionManager {
     private doResurrect;
     private doResurrectFromImport;
     private resolveImportCwd;
+    syncFromAgent(agentId: string): Promise<{
+        synced: SessionRecord[];
+        skipped: number;
+    }>;
+    private collectAgentSessions;
     private bootstrapAgent;
     private attachManagerHooks;
     getHistory(sessionId: string): Promise<HistoryEntry[] | undefined>;
     loadHistory(sessionId: string): Promise<HistoryEntry[]>;
     loadFromDisk(sessionId: string): Promise<ResurrectParams | undefined>;
+    private clearPendingHistorySync;
     private deriveTitleFromHistory;
     get(sessionId: string): Session | undefined;
     activeAgentVersions(): Map<string, Set<string>>;
@@ -2459,6 +2472,7 @@ declare const paths: {
     extensionLogFile: (name: string) => string;
     extensionPidFile: (name: string) => string;
     tuiHistoryFile: (id: string) => string;
+    globalTuiHistoryFile: () => string;
     tuiLogFile: () => string;
 };
 

package/dist/index.js

@@ -87,6 +87,11 @@ var paths = {
   extensionLogFile: (name) => path.join(hydraHome(), "extensions", `${name}.log`),
   extensionPidFile: (name) => path.join(hydraHome(), "extensions", `${name}.pid`),
   tuiHistoryFile: (id) => path.join(hydraHome(), "sessions", id, "prompt-history"),
+  // Cross-session prompt history. Up-arrow / ^R fall through to this
+  // after the per-session list is exhausted. JSONL, one entry per
+  // line, append-only so concurrent TUIs don't lose each other's
+  // writes.
+  globalTuiHistoryFile: () => path.join(hydraHome(), "prompt-history"),
   tuiLogFile: () => path.join(hydraHome(), "tui.log")
 };
 
@@ -1383,6 +1388,10 @@ var SessionListEntry = z3.object({
   updatedAt: z3.string(),
   attachedClients: z3.number().int().nonnegative(),
   status: z3.enum(["live", "cold"]).default("live"),
+  // True while the session is mid-turn (an agent prompt is in flight).
+  // Always false for cold sessions. Lets pickers render a busy dot
+  // without having to attach.
+  busy: z3.boolean().default(false),
   _meta: z3.record(z3.unknown()).optional()
 });
 var SessionListEntryWire = z3.object({
@@ -1399,7 +1408,8 @@ var SessionListResult = z3.object({
 function sessionListEntryToWire(entry) {
   const hydraMeta = {
     attachedClients: entry.attachedClients,
-    status: entry.status
+    status: entry.status,
+    busy: entry.busy
   };
   if (entry.agentId !== void 0) {
     hydraMeta.agentId = entry.agentId;
@@ -4325,6 +4335,12 @@ var SessionRecord = z4.object({
   agentCommands: z4.array(PersistedAgentCommand).optional(),
   agentModes: z4.array(PersistedAgentMode).optional(),
   agentModels: z4.array(PersistedAgentModel).optional(),
+  // One-shot flag set when `hydra agent sync` mints a row from an
+  // agent-side session/list entry: signals that the first resurrect
+  // should *keep* the agent's session/load replay (instead of draining
+  // it) so the local history.jsonl gets populated from the agent's
+  // memory. Cleared after that first resurrect completes.
+  pendingHistorySync: z4.boolean().optional(),
   createdAt: z4.string(),
   updatedAt: z4.string()
 });
@@ -4445,6 +4461,7 @@ function recordFromMemorySession(args) {
     agentCommands: args.agentCommands,
     agentModes: args.agentModes,
     agentModels: args.agentModels,
+    pendingHistorySync: args.pendingHistorySync,
     createdAt: args.createdAt ?? now,
     updatedAt: args.updatedAt ?? now
   };
@@ -4780,7 +4797,13 @@ var SessionManager = class {
       await agent.kill().catch(() => void 0);
       return this.doResurrectFromImport(params);
     }
-    agent.connection.drainBuffered("session/update");
+    if (params.pendingHistorySync === true) {
+      void this.clearPendingHistorySync(params.hydraSessionId).catch(
+        () => void 0
+      );
+    } else {
+      agent.connection.drainBuffered("session/update");
+    }
     const session = new Session({
       sessionId: params.hydraSessionId,
       cwd: params.cwd,
@@ -4870,6 +4893,133 @@ var SessionManager = class {
     }
     return os2.homedir();
   }
+  // Pull every session the agent itself remembers (across all cwds) and
+  // persist a cold hydra record for each one we don't already track.
+  // Used by `hydra agent sync <id>` to surface sessions created outside
+  // hydra — or by other tools — in `hydra session list` so the picker
+  // can resurrect them. Spawns a throwaway agent process for the
+  // initialize + session/list pair, then kills it. Records are minted
+  // with pendingHistorySync:true so the first resurrect records the
+  // agent's session/load replay into history.jsonl rather than dropping
+  // it.
+  async syncFromAgent(agentId) {
+    const agentDef = await this.registry.getAgent(agentId);
+    if (!agentDef) {
+      const err = new Error(
+        `agent ${agentId} not found in registry`
+      );
+      err.code = JsonRpcErrorCodes.AgentNotInstalled;
+      throw err;
+    }
+    const plan = await planSpawn(agentDef, [], {
+      npmRegistry: this.npmRegistry
+    });
+    const agent = this.spawner({
+      agentId,
+      cwd: os2.homedir(),
+      plan
+    });
+    let initResult;
+    try {
+      initResult = await agent.connection.request(
+        "initialize",
+        {
+          protocolVersion: ACP_PROTOCOL_VERSION,
+          clientCapabilities: {},
+          clientInfo: { name: "hydra", version: HYDRA_VERSION }
+        }
+      );
+    } catch (err) {
+      await agent.kill().catch(() => void 0);
+      throw err;
+    }
+    const caps = initResult.agentCapabilities ?? {};
+    if (caps.sessionCapabilities?.list === void 0) {
+      await agent.kill().catch(() => void 0);
+      throw new Error(
+        `agent ${agentId} does not advertise sessionCapabilities.list; cannot sync`
+      );
+    }
+    let entries;
+    try {
+      entries = await this.collectAgentSessions(agent);
+    } catch (err) {
+      await agent.kill().catch(() => void 0);
+      throw err;
+    }
+    await agent.kill().catch(() => void 0);
+    const existing = /* @__PURE__ */ new Set();
+    for (const live of this.sessions.values()) {
+      existing.add(`${live.agentId}::${live.upstreamSessionId}`);
+    }
+    const stored = await this.store.list().catch(() => []);
+    for (const rec of stored) {
+      existing.add(`${rec.agentId}::${rec.upstreamSessionId}`);
+    }
+    const synced = [];
+    let skipped = 0;
+    for (const entry of entries) {
+      const dedupeKey = `${agentId}::${entry.sessionId}`;
+      if (existing.has(dedupeKey)) {
+        skipped += 1;
+        continue;
+      }
+      existing.add(dedupeKey);
+      const newId = `${HYDRA_SESSION_PREFIX}${generateRawSessionId()}`;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const ts = entry.updatedAt ?? now;
+      const recordArgs = {
+        sessionId: newId,
+        lineageId: generateLineageId(),
+        upstreamSessionId: entry.sessionId,
+        agentId,
+        cwd: entry.cwd,
+        pendingHistorySync: true,
+        createdAt: ts,
+        updatedAt: ts
+      };
+      if (entry.title !== void 0) {
+        recordArgs.title = entry.title;
+      }
+      const record = recordFromMemorySession(recordArgs);
+      await this.store.write(record);
+      synced.push({ version: 1, ...record });
+    }
+    return { synced, skipped };
+  }
+  // Paginate the agent's session/list, threading nextCursor until the
+  // agent stops returning one. Each entry the spec guarantees has
+  // { sessionId, cwd }; title and updatedAt are optional.
+  async collectAgentSessions(agent) {
+    const out = [];
+    let cursor;
+    for (let page = 0; page < 100; page += 1) {
+      const params = {};
+      if (cursor !== void 0) {
+        params.cursor = cursor;
+      }
+      const result = await agent.connection.request("session/list", params);
+      const rows = Array.isArray(result.sessions) ? result.sessions : [];
+      for (const row of rows) {
+        if (typeof row.sessionId !== "string" || typeof row.cwd !== "string") {
+          continue;
+        }
+        const entry = { sessionId: row.sessionId, cwd: row.cwd };
+        if (typeof row.title === "string") {
+          entry.title = row.title;
+        }
+        if (typeof row.updatedAt === "string") {
+          entry.updatedAt = row.updatedAt;
+        }
+        out.push(entry);
+      }
+      if (typeof result.nextCursor !== "string" || result.nextCursor.length === 0) {
+        break;
+      }
+      cursor = result.nextCursor;
+    }
+    return out;
+  }
   // Bootstrap a fresh agent process: registry resolve → spawn → initialize
   // → session/new. Shared by create() and the /hydra agent path so both
   // go through the same env / capabilities / error-handling.
@@ -5062,9 +5212,21 @@ var SessionManager = class {
       agentCommands: record.agentCommands,
       agentModes: record.agentModes,
       agentModels: record.agentModels,
-      createdAt: record.createdAt
+      createdAt: record.createdAt,
+      pendingHistorySync: record.pendingHistorySync
     };
   }
+  async clearPendingHistorySync(sessionId) {
+    await this.enqueueMetaWrite(sessionId, async () => {
+      const record = await this.store.read(sessionId);
+      if (!record || record.pendingHistorySync !== true) {
+        return;
+      }
+      const next = { ...record };
+      delete next.pendingHistorySync;
+      await this.store.write(next);
+    });
+  }
   // Best-effort: peek at the persisted history's first prompt and use
   // its first line (capped to 200 chars) as a session title. Returns
   // undefined if no usable prompt is found or any I/O fails.
@@ -5150,7 +5312,8 @@ var SessionManager = class {
         currentUsage: session.currentUsage,
         updatedAt: used,
         attachedClients: session.attachedCount,
-        status: "live"
+        status: "live",
+        busy: session.turnStartedAt !== void 0
       });
     }
     const records = await this.store.list().catch(() => []);
@@ -5174,7 +5337,8 @@ var SessionManager = class {
         importedFromUpstreamSessionId: r.importedFromUpstreamSessionId,
         updatedAt: used,
         attachedClients: 0,
-        status: "cold"
+        status: "cold",
+        busy: false
       });
     }
     entries.sort((a, b) => a.updatedAt < b.updatedAt ? 1 : -1);
@@ -7461,7 +7625,7 @@ function registerSessionRoutes(app, manager, defaults) {
 }
 
 // src/daemon/routes/agents.ts
-function registerAgentRoutes(app, registry) {
+function registerAgentRoutes(app, registry, manager, opts = {}) {
   app.get("/v1/agents", async () => {
     const doc = await registry.load();
     return {
@@ -7482,6 +7646,61 @@ function registerAgentRoutes(app, registry) {
     const doc = await registry.refresh();
     return { version: doc.version, agentCount: doc.agents.length };
   });
+  app.post("/v1/agents/:id/install", async (request, reply) => {
+    const id = request.params.id;
+    const agent = await registry.getAgent(id);
+    if (!agent) {
+      reply.code(404).send({ error: `agent ${id} not found in registry` });
+      return;
+    }
+    if (agent.distribution.uvx && !agent.distribution.npx && !agent.distribution.binary) {
+      reply.send({
+        agentId: agent.id,
+        version: agent.version ?? "current",
+        distribution: "uvx",
+        installed: false,
+        message: "uvx agents resolve on first run; nothing to pre-install."
+      });
+      return;
+    }
+    try {
+      const plan = await planSpawn(agent, [], { npmRegistry: opts.npmRegistry });
+      const distribution = agent.distribution.npx ? "npx" : agent.distribution.binary ? "binary" : "unknown";
+      reply.send({
+        agentId: agent.id,
+        version: plan.version,
+        distribution,
+        installed: true,
+        command: plan.command
+      });
+    } catch (err) {
+      reply.code(500).send({ error: err.message });
+    }
+  });
+  app.post("/v1/agents/:id/sync", async (request, reply) => {
+    const agentId = request.params.id;
+    try {
+      const { synced, skipped } = await manager.syncFromAgent(agentId);
+      return {
+        synced: synced.map((r) => ({
+          sessionId: r.sessionId,
+          upstreamSessionId: r.upstreamSessionId,
+          agentId: r.agentId,
+          cwd: r.cwd,
+          title: r.title,
+          updatedAt: r.updatedAt
+        })),
+        skipped
+      };
+    } catch (err) {
+      const e = err;
+      if (e.code === JsonRpcErrorCodes.AgentNotInstalled) {
+        reply.code(404).send({ error: e.message });
+        return;
+      }
+      reply.code(409).send({ error: e.message });
+    }
+  });
 }
 
 // src/daemon/routes/health.ts
@@ -8597,7 +8816,7 @@ async function startDaemon(config, serviceToken) {
     agentId: config.defaultAgent,
     cwd: config.defaultCwd
   });
-  registerAgentRoutes(app, registry);
+  registerAgentRoutes(app, registry, manager, { npmRegistry: config.npmRegistry });
   registerExtensionRoutes(app, extensions);
   registerConfigRoutes(app, {
     defaultAgent: config.defaultAgent,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hydra-acp/cli",
-  "version": "0.1.40",
+  "version": "0.1.42",
   "description": "Multi-client ACP session daemon: spawn agents, attach over WSS, multiplex sessions across editors.",
   "license": "MIT",
   "type": "module",