@harness-kernel/core 0.1.1 → 0.2.1

package/dist/{chunk-4WWSQAWA.js → chunk-QEVKKJ7N.js}

@@ -17,10 +17,11 @@ import {
 import {
   HarnessSandboxSession,
   NoopSandbox
-} from "./chunk-AD3BCYWU.js";
+} from "./chunk-ZU6ADDET.js";
 import {
-  NoopRunStorage
-} from "./chunk-AZVA22HW.js";
+  HarnessSessionStorage,
+  MemorySessionStorage
+} from "./chunk-ONYDIU4X.js";
 import {
   ContextReadyEvent,
   ErrorEvent,
@@ -43,7 +44,7 @@ import {
   TurnEndEvent,
   TurnStartEvent,
   runtimeEventClasses
-} from "./chunk-4SYLFKIX.js";
+} from "./chunk-JIJHGB6H.js";
 import {
   normalizeSchema
 } from "./chunk-OBKS4AJR.js";
@@ -58,7 +59,7 @@ import {
   systemRole,
   toolRole,
   userRole
-} from "./chunk-4A2P4QU5.js";
+} from "./chunk-B4Q6CPYO.js";
 
 // src/logging/tool-errors.ts
 function createToolErrorPayload(input) {
@@ -576,7 +577,7 @@ var SandboxManager = class {
       agentKey: this.input.agentKey,
       workDir: this.input.workDir,
       outputDir: this.input.getOutputDir(),
-      services: this.input.services
+      resources: this.input.resources
     });
     this.session = this.wrap(opened);
     this.input.logOpened({ sandboxId: opened.id, workDir: opened.workDir });
@@ -633,7 +634,7 @@ var RunStorageCoordinator = class {
   constructor(input) {
     this.input = input;
     this.runIdValue = input.runId;
-    this.storePromise = this.createStore(this.runIdValue);
+    this.createRunOnOpen = !input.openExistingRun;
   }
   input;
   runIdValue;
@@ -641,6 +642,7 @@ var RunStorageCoordinator = class {
   storePromise;
   initialized = false;
   runtimeLoaded = false;
+  createRunOnOpen;
   get runDir() {
     return this.store?.runDir;
   }
@@ -664,6 +666,7 @@ var RunStorageCoordinator = class {
     await this.write("save_transcript", (store) => store.saveTranscript(messages));
   }
   async saveMetrics(metrics) {
+    if (this.input.storage instanceof HarnessSessionStorage) return;
     await this.write("save_metrics", (store) => store.saveMetrics(metrics));
   }
   async saveSnapshot(snapshot) {
@@ -685,16 +688,27 @@ var RunStorageCoordinator = class {
     await this.close();
     this.runIdValue = runId;
     this.store = void 0;
-    this.storePromise = this.createStore(runId);
+    this.storePromise = void 0;
     this.initialized = false;
     this.runtimeLoaded = false;
+    this.createRunOnOpen = true;
   }
   async close() {
-    const store = this.store ?? await this.storePromise;
-    await store.close?.();
+    const store = this.store ?? (this.storePromise ? await this.storePromise : void 0);
+    await store?.close?.();
   }
   async createStore(runId) {
     try {
+      if (this.input.storage instanceof HarnessSessionStorage && this.createRunOnOpen) {
+        await this.input.storage.createRun({
+          runId,
+          sessionId: this.input.sessionId,
+          agentKey: this.input.agentKey,
+          outputDir: this.input.outputDir,
+          mode: this.input.mode()
+        });
+      }
+      this.createRunOnOpen = false;
       const store = await this.input.storage.openRun({
         runId,
         sessionId: this.input.sessionId,
@@ -710,6 +724,7 @@ var RunStorageCoordinator = class {
   }
   async getStore() {
     if (this.store) return this.store;
+    this.storePromise ??= this.createStore(this.runIdValue);
     this.store = await this.storePromise;
     return this.store;
   }
@@ -1228,7 +1243,15 @@ var ToolExecutor = class {
       return result;
     }
     const approved = await this.approveTool(
-      { id, name: input.tool.name, args: parsedArgs.data, modeId: this.input.getCurrentMode(), risk: input.tool.risk, permissions: input.tool.permissions },
+      {
+        id,
+        name: input.tool.name,
+        args: parsedArgs.data,
+        modeId: this.input.getCurrentMode(),
+        risk: input.tool.risk,
+        permissions: input.tool.permissions,
+        approvalTimeoutMs: input.tool.approvalTimeoutMs
+      },
       input.tool,
       parsedArgs.data,
       callerEventOptions
@@ -1728,13 +1751,15 @@ var AgentSessionRunner = class {
     this.options = options;
     this.agent = normalizeAgent(options.agent);
     this.sessionIdValue = options.sessionId ?? randomId();
+    this.runIdValue = options.initialRunId ?? randomId();
+    this.restoredFromRun = Boolean(options.initialRunId);
     this.workDir = options.workDir ?? ".";
     this.outputDir = options.outputDir ?? ".harness-kernel/runs";
-    const storage = options.storage ?? new NoopRunStorage();
+    const storage = options.storage ?? new MemorySessionStorage();
     const sandbox = options.sandbox ?? new NoopSandbox();
     this.providerRegistry = new HarnessModelProviderRegistry(options.providers);
-    this.currentMode = options.initialMode ? this.resolveModeType(options.initialMode) : this.agent.initialMode;
-    this.services = options.services ?? {};
+    this.currentMode = this.agent.initialMode;
+    this.resources = options.resources ?? {};
     this.roles = validateRoles(options.roles) ?? this.agent.roles ?? defaultRoles();
     const initialProvider = this.resolveModelProvider(options.defaultModel).provider;
     this.roleResolver = new RoleResolver(this.roles, {
@@ -1748,6 +1773,8 @@ var AgentSessionRunner = class {
       sessionId: this.sessionIdValue,
       agentKey: this.agent.key,
       outputDir: this.outputDir,
+      mode: () => this.currentMode,
+      openExistingRun: Boolean(options.initialRunId),
       logOpened: (fields) => this.log(RunStorageOpenedLog, fields),
       logFailed: (fields) => this.log(StorageWriteFailedLog, fields)
     });
@@ -1836,7 +1863,7 @@ var AgentSessionRunner = class {
       sessionId: this.sessionIdValue,
       agentKey: this.agent.key,
       workDir: this.workDir,
-      services: this.services,
+      resources: this.resources,
       getRunId: () => this.runId,
       getOutputDir: () => this.storeRunDir(),
       logOpened: (fields) => this.log(SandboxOpenedLog, fields),
@@ -1848,7 +1875,7 @@ var AgentSessionRunner = class {
     this.toolExecutor = new ToolExecutor({
       getMetrics: () => this.metrics,
       getCurrentMode: () => this.currentMode,
-      getToolApprovalMode: () => this.options.toolApproval ?? this.getModeDefinition(this.currentMode).toolApproval,
+      getToolApprovalMode: () => this.getModeDefinition(this.currentMode).toolApproval,
       approveTool: this.options.approveTool,
       ensureSandboxOpen: () => this.ensureSandboxOpen(),
       buildActionSession: (tool, source, correlationId, causationId) => this.buildActionSession(tool, source, correlationId, causationId),
@@ -1899,7 +1926,7 @@ var AgentSessionRunner = class {
   snapshotManager;
   toolExecutor;
   modelPipeline;
-  services;
+  resources;
   roles;
   roleResolver;
   providerRegistry;
@@ -1917,6 +1944,7 @@ var AgentSessionRunner = class {
   providerStack = [];
   hookDepth = 0;
   turnHandoffRequested = false;
+  restoredFromRun = false;
   logSource(source) {
     if (!source) return { kind: "runtime" };
     return {
@@ -2012,11 +2040,12 @@ var AgentSessionRunner = class {
     });
   }
   async beginNewRun() {
-    if (this.started) {
+    if (this.started || this.restoredFromRun) {
       await this.closeSandbox();
       this.runIdValue = randomId();
       await this.storageCoordinator.beginRun(this.runIdValue);
       this.started = false;
+      this.restoredFromRun = false;
     }
     this.startedAtPerf = 0;
     this.metrics = emptyMetrics();
@@ -2039,7 +2068,7 @@ var AgentSessionRunner = class {
         role: options.userRole,
         external: true
       });
-      const maxRunnerTurns = this.options.maxTurns ?? 5;
+      const maxRunnerTurns = this.getModeDefinition(this.currentMode).maxTurns ?? 5;
       while (this.pendingInputs.length > 0 && this.metrics.turnCount < maxRunnerTurns) {
         if (options.signal?.aborted) throw new Error("Run aborted.");
         const input = this.pendingInputs.shift();
@@ -2060,7 +2089,8 @@ var AgentSessionRunner = class {
       this.log(RunCompletedLog, {
         durationMs: this.metrics.durationMs,
         messageCount: this.metrics.messageCount,
-        eventCount: this.metrics.eventCount
+        eventCount: this.metrics.eventCount,
+        metrics: cloneJSON4(this.metrics)
       });
       return {
         runId: this.runId,
@@ -2082,6 +2112,10 @@ var AgentSessionRunner = class {
   async prompt(message, options = {}) {
     return this.run(message, options);
   }
+  async hydrate() {
+    if (!this.restoredFromRun) return;
+    await this.ensureStoreInitialized();
+  }
   async close() {
     await this.closeSandbox();
     await this.closeStore();
@@ -2370,7 +2404,7 @@ var AgentSessionRunner = class {
       agentKey: this.agent.key,
       workDir: this.workDir,
       outputDir: this.storeRunDir(),
-      services: this.services,
+      resources: this.resources,
       state: {
         get: () => cloneJSON4(this.state)
       },
@@ -2936,17 +2970,18 @@ var ApprovalController = class {
   }
   request(request) {
     return new Promise((resolve) => {
+      const timeoutMs = request.approvalTimeoutMs ?? this.input.defaultTimeoutMs;
       const handle = createToolApprovalHandle({
         sessionId: this.input.sessionId,
         runId: this.input.getRunId(),
         request,
-        timeoutMs: this.input.timeoutMs,
+        timeoutMs,
         approve: async (id) => this.resolve(id, true),
         deny: async (id, reason) => this.resolve(id, false, reason)
       });
-      const timeout = setTimeout(() => {
+      const timeout = timeoutMs > 0 ? setTimeout(() => {
         this.resolve(handle.id, false);
-      }, this.input.timeoutMs);
+      }, timeoutMs) : void 0;
       this.pendingApprovals.set(handle.id, {
         handle,
         timeout,
@@ -2974,11 +3009,8 @@ var ApprovalController = class {
 async function resolveAgent(input) {
   return input.definition;
 }
-function resolveWorkDir(workDir) {
-  return workDir ?? ".";
-}
 function resolveStorage(storage) {
-  return storage ?? new NoopRunStorage();
+  return storage ?? new MemorySessionStorage();
 }
 
 // src/session/event-hub.ts
@@ -3353,14 +3385,6 @@ function nowIso6() {
 function normalizeInput(input) {
   return typeof input === "string" ? { content: input } : input;
 }
-function resolveInitialMode(agent, mode) {
-  if (mode === void 0) return void 0;
-  if (typeof mode !== "string") return mode;
-  if (!Array.isArray(agent.modes)) return void 0;
-  const resolved = agent.modes.find((candidate) => getConstructType(candidate) === mode);
-  if (!resolved) throw new Error(`Unknown initial mode '${mode}'.`);
-  return resolved;
-}
 function toErrorShape(error) {
   if (error instanceof Error) {
     return {
@@ -3376,6 +3400,8 @@ var HarnessSessionImpl = class {
   constructor(config, input) {
     this.config = config;
     this.id = input.sessionId ?? randomId();
+    this.createdAt = input.restoredSession?.createdAt ?? this.createdAt;
+    this.lastActiveAt = input.restoredSession?.lastActiveAt ?? this.createdAt;
     this.events = new SessionEventHub({
       sessionId: this.id,
       hydrateApprovalId: (toolCallId) => this.approvals.hydrateApprovalId(toolCallId)
@@ -3384,7 +3410,7 @@ var HarnessSessionImpl = class {
     this.approvals = new ApprovalController({
       sessionId: this.id,
       getRunId: () => this.runner.runId,
-      timeoutMs: this.config.toolApprovalTimeoutMs ?? defaultApprovalTimeoutMs,
+      defaultTimeoutMs: defaultApprovalTimeoutMs,
       notifyRequested: (approval) => this.notify({ type: "tool.approval.requested", approval })
     });
     const storage = resolveStorage(config.storage);
@@ -3394,12 +3420,9 @@ var HarnessSessionImpl = class {
       providers: config.providers,
       defaultModel: config.defaultModel,
       sandbox: config.sandbox,
-      workDir: input.workDir,
       storage,
-      initialMode: resolveInitialMode(input.agent, config.initialMode),
-      toolApproval: config.toolApproval,
-      maxTurns: config.maxTurns,
-      services: config.services,
+      initialRunId: input.restoredSession?.latestRunId,
+      resources: config.resources,
       approveTool: (request) => this.requestToolApproval(request),
       logger: this.logger
     });
@@ -3608,6 +3631,9 @@ var HarnessSessionImpl = class {
     this.events.clear();
     await this.logger.close();
   }
+  async hydrate() {
+    await this.runner.hydrate();
+  }
   notify(event) {
     this.events.notify(event);
   }
@@ -3652,13 +3678,26 @@ var HarnessSessionImpl = class {
   }
 };
 async function createHarnessSession(config, options = {}) {
-  const workDir = resolveWorkDir(config.workDir);
   const agent = await resolveAgent(config.agent);
-  return new HarnessSessionImpl(config, {
+  const storage = resolveStorage(config.storage);
+  const sessionConfig = { ...config, storage };
+  const session = new HarnessSessionImpl(sessionConfig, {
     sessionId: options.sessionId,
     agent,
-    workDir
+    restoredSession: options.restoredSession
   });
+  if (!options.restoredSession) {
+    const status = session.getStatus();
+    await storage.createSession({
+      sessionId: status.sessionId,
+      agentKey: status.agentKey,
+      createdAt: status.createdAt,
+      lastActiveAt: status.lastActiveAt,
+      mode: status.mode
+    });
+  }
+  await session.hydrate();
+  return session;
 }
 
 // src/session/store.ts
@@ -3668,53 +3707,150 @@ function mergeConfig(base, overrides) {
     ...overrides,
     agent: overrides?.agent ?? base.agent,
     providers: overrides?.providers ?? base.providers,
-    services: overrides?.services ?? base.services,
-    logging: overrides?.logging ?? base.logging
+    resources: overrides?.resources ?? base.resources,
+    logging: overrides?.logging ?? base.logging,
+    storage: overrides?.storage ?? base.storage
+  };
+}
+function statusToSummary(status, latestRunId) {
+  return {
+    sessionId: status.sessionId,
+    agentKey: status.agentKey,
+    createdAt: status.createdAt,
+    lastActiveAt: status.lastActiveAt,
+    mode: status.mode,
+    latestRunId
+  };
+}
+function sortSummaries(items) {
+  return [...items].sort((a, b) => {
+    const byLastActive = b.lastActiveAt.localeCompare(a.lastActiveAt);
+    return byLastActive || a.sessionId.localeCompare(b.sessionId);
+  });
+}
+function encodeCursor(summary) {
+  return Buffer.from(JSON.stringify([summary.lastActiveAt, summary.sessionId]), "utf8").toString("base64url");
+}
+function decodeCursor(cursor) {
+  if (!cursor) return void 0;
+  try {
+    const parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+    if (!Array.isArray(parsed) || typeof parsed[0] !== "string" || typeof parsed[1] !== "string") return void 0;
+    return [parsed[0], parsed[1]];
+  } catch {
+    return void 0;
+  }
+}
+function paginateActive(items, query) {
+  const limit = Math.max(1, Math.min(query?.limit ?? 50, 100));
+  const cursor = decodeCursor(query?.cursor);
+  const filtered = sortSummaries(items).filter((summary) => !query?.agentKey || summary.agentKey === query.agentKey).filter((summary) => {
+    if (!cursor) return true;
+    const [lastActiveAt, sessionId] = cursor;
+    return summary.lastActiveAt < lastActiveAt || summary.lastActiveAt === lastActiveAt && summary.sessionId > sessionId;
+  });
+  const page = filtered.slice(0, limit);
+  return {
+    items: page,
+    nextCursor: filtered.length > limit && page.length > 0 ? encodeCursor(page[page.length - 1]) : void 0
   };
 }
 var HarnessSessionStoreImpl = class {
   constructor(config) {
     this.config = config;
+    this.storage = config.storage ?? new MemorySessionStorage();
   }
   config;
   sessions = /* @__PURE__ */ new Map();
   unsubscriptions = /* @__PURE__ */ new Map();
+  latestRunIds = /* @__PURE__ */ new Map();
   listeners = /* @__PURE__ */ new Set();
+  storage;
   closed = false;
+  async init() {
+    await this.storage.init?.();
+  }
   async getOrCreate(sessionId, overrides) {
-    this.cleanupExpired();
     if (this.closed) throw new Error("Harness session store is closed.");
     const id = sessionId?.trim() || randomId();
     const existing = this.sessions.get(id);
     if (existing) return existing;
-    const session = await createHarnessSession(mergeConfig(this.config, overrides), { sessionId: id });
+    const config = mergeConfig({ ...this.config, storage: this.storage }, overrides);
+    const stored = await this.storage.getSession(id);
+    const session = await createHarnessSession(config, { sessionId: id, restoredSession: stored });
+    const status = session.getStatus();
+    if (stored?.latestRunId) this.latestRunIds.set(id, stored.latestRunId);
+    else this.latestRunIds.delete(id);
+    if (!stored) {
+      await this.storage.createSession({
+        sessionId: id,
+        agentKey: status.agentKey,
+        createdAt: status.createdAt,
+        lastActiveAt: status.lastActiveAt,
+        mode: status.mode
+      });
+    }
     this.sessions.set(id, session);
-    this.unsubscriptions.set(id, session.on((event) => this.notify({ type: "session.event", sessionId: id, event })));
-    this.notify({ type: "session.created", sessionId: id, status: session.getStatus() });
+    this.unsubscriptions.set(id, session.on((event) => {
+      if (event.type === "run.started") this.latestRunIds.set(id, event.runId);
+      if (event.type === "run.completed") this.latestRunIds.set(id, event.result.runId);
+      if (event.type === "session.status") {
+        void this.storage.touchSession({
+          sessionId: id,
+          lastActiveAt: event.status.lastActiveAt,
+          mode: event.status.mode
+        });
+      }
+      this.notify({ type: "session.event", sessionId: id, event });
+    }));
+    this.notify({ type: "session.created", sessionId: id, status });
     return session;
   }
   get(sessionId) {
-    this.cleanupExpired();
     return this.sessions.get(sessionId);
   }
-  list() {
-    this.cleanupExpired();
-    return [...this.sessions.values()].map((session) => session.getStatus());
+  async list(query) {
+    if (query?.active) {
+      return paginateActive([...this.sessions.values()].map((session) => statusToSummary(session.getStatus(), this.latestRunIds.get(session.id))), query);
+    }
+    const result = await this.storage.listSessions(query);
+    const active = new Map([...this.sessions.values()].map((session) => [session.id, statusToSummary(session.getStatus(), this.latestRunIds.get(session.id))]));
+    return {
+      items: result.items.map((item) => active.get(item.sessionId) ?? item),
+      nextCursor: result.nextCursor
+    };
   }
-  async delete(sessionId) {
+  async close(sessionId) {
+    if (sessionId === void 0) {
+      if (this.closed) return;
+      this.closed = true;
+      await this.closeAll();
+      this.listeners.clear();
+      return;
+    }
     const session = this.sessions.get(sessionId);
     if (!session) return false;
     this.sessions.delete(sessionId);
+    this.latestRunIds.delete(sessionId);
     this.unsubscriptions.get(sessionId)?.();
     this.unsubscriptions.delete(sessionId);
     await session.close();
-    this.notify({ type: "session.deleted", sessionId });
     return true;
   }
-  async clear() {
-    for (const sessionId of [...this.sessions.keys()]) await this.delete(sessionId);
+  async delete(sessionId) {
+    await this.close(sessionId);
+    this.latestRunIds.delete(sessionId);
+    const deleted = await this.storage.deleteSession(sessionId);
+    if (deleted) this.notify({ type: "session.deleted", sessionId });
+    return deleted;
+  }
+  async clearActive() {
+    await this.closeAll();
     this.notify({ type: "session.cleared" });
   }
+  async closeAll() {
+    for (const sessionId of [...this.sessions.keys()]) await this.close(sessionId);
+  }
   async send(sessionId, input, options) {
     const session = await this.getOrCreate(sessionId);
     return session.send(input, options);
@@ -3744,26 +3880,14 @@ var HarnessSessionStoreImpl = class {
     this.listeners.add(listener);
     return () => this.listeners.delete(listener);
   }
-  async close() {
-    if (this.closed) return;
-    this.closed = true;
-    await this.clear();
-    this.listeners.clear();
-  }
   notify(event) {
     for (const listener of this.listeners) void listener(event);
   }
-  cleanupExpired() {
-    const ttl = this.config.sessionTtlMs;
-    if (!ttl || ttl <= 0) return;
-    const cutoff = Date.now() - ttl;
-    for (const session of [...this.sessions.values()]) {
-      if (Date.parse(session.getStatus().lastActiveAt) < cutoff) void this.delete(session.id);
-    }
-  }
 };
 async function createHarnessSessionStore(config) {
-  return new HarnessSessionStoreImpl(config);
+  const store = new HarnessSessionStoreImpl(config);
+  await store.init();
+  return store;
 }
 
 export {
@@ -3775,4 +3899,4 @@ export {
   HarnessSessionStoreImpl,
   createHarnessSessionStore
 };
-//# sourceMappingURL=chunk-4WWSQAWA.js.map
+//# sourceMappingURL=chunk-QEVKKJ7N.js.map