@zhivex-ai/harness 1.3.0-rc.3 → 1.3.0

package/dist/{index-2aymdsqc.js → index-qfpz5y2v.js}

@@ -123,12 +123,36 @@ var scoped = { projectId: id };
 var session = { ...scoped, sessionId: id };
 var run = { ...session, runId: id };
 var mutation = { idempotencyKey: id };
+var checkpoint = { ...session, checkpointId: z.string().uuid() };
+var restore = { ...session, operationId: z.string().uuid() };
+var fileDigest = z.string().regex(/^sha256:[a-f0-9]{64}$/);
 var harnessClientCommandSchema = z.discriminatedUnion("method", [
   z.object({ method: z.literal("project.get"), ...scoped }).strict(),
+  z.object({ method: z.literal("policy.get"), ...scoped }).strict(),
   z.object({ method: z.literal("session.list"), ...scoped, search: z.string().max(256).optional() }).strict(),
   z.object({ method: z.literal("session.create"), ...scoped, ...mutation, title: z.string().max(256).optional() }).strict(),
   z.object({ method: z.literal("session.get"), ...session }).strict(),
   z.object({ method: z.literal("session.rename"), ...session, ...mutation, expectedRevision: revision, title: z.string().max(256) }).strict(),
+  z.object({ method: z.literal("checkpoint.list"), ...session }).strict(),
+  z.object({ method: z.literal("checkpoint.inspect"), ...checkpoint }).strict(),
+  z.object({
+    method: z.literal("checkpoint.capture"),
+    ...session,
+    ...mutation,
+    expectedRevision: revision,
+    turnId: id,
+    paths: z.array(z.string().min(1).max(1024)).min(1).max(20)
+  }).strict(),
+  z.object({
+    method: z.literal("restore.prepare"),
+    ...checkpoint,
+    ...mutation,
+    expectedRevision: revision,
+    expected: z.record(z.string().min(1).max(1024), fileDigest).refine((value) => Object.keys(value).length >= 1 && Object.keys(value).length <= 20)
+  }).strict(),
+  z.object({ method: z.literal("restore.get"), ...restore }).strict(),
+  z.object({ method: z.literal("restore.apply"), ...restore, ...mutation, expectedRevision: revision, reviewedProposalId: fileDigest }).strict(),
+  z.object({ method: z.literal("restore.recoverFork"), ...restore, ...mutation, expectedRevision: revision, forkSessionId: id }).strict(),
   z.object({ method: z.literal("run.start"), ...session, ...mutation, expectedRevision: revision, prompt: z.string().min(1).max(64 * 1024) }).strict(),
   z.object({ method: z.literal("run.get"), ...run, includeReview: z.boolean().optional(), includeDiff: z.boolean().optional(), decisionOffset: z.number().int().min(0).max(512).optional() }).strict(),
   z.object({

package/dist/{index-kfgt9yqq.js → index-w2sj0wkw.js}

@@ -1,14 +1,17 @@
 import {
-  createHarnessClientAdapter
-} from "./index-5wjwe91x.js";
+  createHarnessClientAdapter,
+  harnessPolicyDecisionEventSchema
+} from "./index-hnaxfpb5.js";
 import {
-  SqliteDatabase,
   openCliSessionStore
-} from "./index-pgqz45fj.js";
+} from "./index-42gp2hy8.js";
+import {
+  SqliteDatabase
+} from "./index-yb239ghk.js";
 import {
   harnessClientRequestSchema,
   streamEventDocument
-} from "./index-2aymdsqc.js";
+} from "./index-qfpz5y2v.js";
 import {
   __require
 } from "./index-1bx83sw4.js";
@@ -139,6 +142,9 @@ var openHarnessActivityStore = async (config, options = {}) => {
     }
   };
   return {
+    policyDecision(sessionId, runId, event) {
+      write(sessionId, runId, redactValue(harnessPolicyDecisionEventSchema.parse(event)));
+    },
     prompt(sessionId, runId, prompt) {
       const safe = redact(prompt);
       const truncated = Buffer.byteLength(safe) > 60 * 1024;
@@ -193,10 +199,10 @@ var openHarnessActivityStore = async (config, options = {}) => {
       if (after > current.state.sequence)
         throw new Error("ACTIVITY_CURSOR_AHEAD");
       if (expired)
-        return { schemaVersion: 1, cursorExpired: true, nextCursor: current.state.sequence, events: [], snapshot: current.state };
-      const rows = db.query("SELECT sequence,session,run,at,activity FROM client_activity_events WHERE scope=? AND session=? AND sequence>? ORDER BY sequence LIMIT 200").all(scope, sessionId, after);
-      const events = rows.map((row) => ({ schemaVersion: 1, eventId: createHash("sha256").update(`${scope}:${row.sequence}`).digest("hex"), sequence: row.sequence, sessionId: row.session, runId: row.run, at: row.at, activity: JSON.parse(row.activity) }));
-      return { schemaVersion: 1, cursorExpired: false, nextCursor: events.at(-1)?.sequence ?? after, events };
+        return { schemaVersion: 1, cursorExpired: true, hasMore: false, policyEvidenceIncomplete: true, nextCursor: current.state.sequence, events: [], snapshot: current.state };
+      const rows = db.query("SELECT sequence,session,run,at,activity FROM client_activity_events WHERE scope=? AND session=? AND sequence>? ORDER BY sequence LIMIT 201").all(scope, sessionId, after);
+      const events = rows.slice(0, 200).map((row) => ({ schemaVersion: 1, eventId: createHash("sha256").update(`${scope}:${row.sequence}`).digest("hex"), sequence: row.sequence, sessionId: row.session, runId: row.run, at: row.at, activity: JSON.parse(row.activity) }));
+      return { schemaVersion: 1, cursorExpired: false, hasMore: rows.length > 200, policyEvidenceIncomplete: current.expiredThrough > 0, nextCursor: events.at(-1)?.sequence ?? after, events };
     },
     close() {
       db.close();
@@ -312,7 +318,7 @@ var startHarnessLocalService = async (harness, options) => {
       }
       const parsed = harnessClientRequestSchema.safeParse(value);
       const method = parsed.success ? parsed.data.command.method : undefined;
-      const mutation = method !== undefined && !["project.get", "session.list", "session.get", "run.get"].includes(method);
+      const mutation = method !== undefined && !["project.get", "policy.get", "session.list", "session.get", "run.get", "checkpoint.list", "checkpoint.inspect", "restore.get"].includes(method);
       if (paused && mutation && method !== "run.cancel")
         return send(res, 503, fault("SERVICE_PAUSED"));
       if (mutation)
@@ -359,6 +365,7 @@ var startHarnessLocalService = async (harness, options) => {
     });
     adapter = await createHarnessClientAdapter(harness, {
       ...options.approvalNow ? { now: options.approvalNow } : {},
+      onPolicyDecision: (sessionId, runId, event) => activity.policyDecision(sessionId, runId, event),
       onPrompt: (sessionId, runId, prompt) => activity.prompt(sessionId, runId, prompt),
       onEvent: (sessionId, runId, event) => activity.append(sessionId, runId, event),
       onCheckpoint: (sessionId, runId, status) => activity.checkpoint(sessionId, runId, status)
@@ -377,6 +384,22 @@ var startHarnessLocalService = async (harness, options) => {
     return {
       socketPath,
       credentialsPath,
+      async dispatchReviewed(request) {
+        if (closing || paused)
+          throw new Error("SERVICE_ADMISSION_PAUSED");
+        if (!adapter?.dispatchReviewed)
+          throw new Error("EXPLICIT_REVIEW_UNAVAILABLE");
+        activeMutations++;
+        const operation = adapter.dispatchReviewed(request);
+        const tracked = operation.then(() => {}, () => {});
+        pending.add(tracked);
+        try {
+          return await operation;
+        } finally {
+          pending.delete(tracked);
+          activeMutations--;
+        }
+      },
       pauseAdmission() {
         if (closing)
           throw new Error("SERVICE_CLOSING");

package/dist/index-wg1sd3at.js

@@ -0,0 +1,80 @@
+import {
+  bundledModelCatalog,
+  modelCatalogSchema
+} from "./index-xqxeypt5.js";
+
+// src/models/catalog-store.ts
+import { mkdir, readFile, rename, writeFile, unlink } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+var MAX_BYTES = 1024 * 1024;
+var TTL = 60 * 60 * 1000;
+async function loadModelCatalog(options = {}) {
+  const fallback = { catalog: bundledModelCatalog, source: "bundled", stale: false };
+  const source = options.url ?? process.env.ZHIVEX_MODEL_CATALOG_URL;
+  if (!source)
+    return fallback;
+  let url;
+  try {
+    url = new URL(source);
+    if (url.protocol !== "https:" || url.username || url.password || url.hash)
+      return { ...fallback, stale: true };
+  } catch {
+    return { ...fallback, stale: true };
+  }
+  const now = options.now ?? Date.now();
+  const directory = options.cacheDirectory ?? path.join(homedir(), ".zhivex", "model-catalog");
+  const file = path.join(directory, `${createHash("sha256").update(url.href).digest("hex")}.json`);
+  let cached;
+  try {
+    const raw = await readFile(file, "utf8");
+    if (Buffer.byteLength(raw) > MAX_BYTES + 1024)
+      throw new Error("CATALOG_TOO_LARGE");
+    const envelope = JSON.parse(raw);
+    if (envelope.url !== url.href || !Number.isFinite(envelope.fetchedAt))
+      throw new Error("INVALID_CACHE");
+    cached = { catalog: modelCatalogSchema.parse(envelope.catalog), source: "cache", stale: true };
+    if (!options.refresh && now >= envelope.fetchedAt && now - envelope.fetchedAt < TTL)
+      return { ...cached, stale: false };
+  } catch {}
+  try {
+    const response = await (options.fetcher ?? fetch)(url, {
+      signal: AbortSignal.timeout(3000),
+      redirect: "error",
+      headers: { accept: "application/json" }
+    });
+    if (!response.ok || !response.body)
+      throw new Error("CATALOG_FETCH_FAILED");
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    try {
+      for (;; ) {
+        const { value, done } = await reader.read();
+        if (done)
+          break;
+        size += value.byteLength;
+        if (size > MAX_BYTES)
+          throw new Error("CATALOG_TOO_LARGE");
+        chunks.push(value);
+      }
+    } finally {
+      await reader.cancel().catch(() => {});
+    }
+    const catalog = modelCatalogSchema.parse(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    try {
+      await mkdir(directory, { recursive: true, mode: 448 });
+      await writeFile(temporary, JSON.stringify({ url: url.href, fetchedAt: now, catalog }), { mode: 384, flag: "wx" });
+      await rename(temporary, file);
+    } catch {} finally {
+      await unlink(temporary).catch(() => {});
+    }
+    return { catalog, source: "remote", stale: false };
+  } catch {
+    return cached ?? { ...fallback, stale: true };
+  }
+}
+
+export { loadModelCatalog };