@zhivex-ai/harness 1.2.0 → 1.3.0-rc.7

package/dist/index-1bx83sw4.js

@@ -0,0 +1,4 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+export { __require };

package/dist/index-2gz7jv7g.js

@@ -0,0 +1,549 @@
+import {
+  createHarnessClientAdapter,
+  harnessPolicyDecisionEventSchema
+} from "./index-jgrx804e.js";
+import {
+  openCliSessionStore
+} from "./index-42gp2hy8.js";
+import {
+  SqliteDatabase
+} from "./index-yb239ghk.js";
+import {
+  harnessClientRequestSchema,
+  streamEventDocument
+} from "./index-qfpz5y2v.js";
+import {
+  __require
+} from "./index-1bx83sw4.js";
+
+// src/client/service-events.ts
+import { createHash } from "node:crypto";
+import { createRedactionPolicy } from "@zhivex-ai/agents";
+var openHarnessActivityStore = async (config, options = {}) => {
+  const index = await openCliSessionStore({ workspace: config.workspace, stateDirectory: config.stateDirectory, scope: config.scope });
+  const scope = `${index.workspaceKey}:${index.scopeKey}`;
+  const db = new SqliteDatabase(index.databasePath);
+  index.close();
+  const maxEvents = options.maxEvents ?? 1e4, retentionMs = options.retentionMs ?? 7 * 24 * 3600 * 1000, now = options.now ?? Date.now;
+  if (!Number.isSafeInteger(maxEvents) || maxEvents < 1 || maxEvents > 1e5 || !Number.isSafeInteger(retentionMs) || retentionMs < 1) {
+    db.close();
+    throw new Error("ACTIVITY_LIMIT_INVALID");
+  }
+  db.exec(`CREATE TABLE IF NOT EXISTS client_activity_events(sequence INTEGER PRIMARY KEY AUTOINCREMENT, scope TEXT NOT NULL, session TEXT NOT NULL, run TEXT NOT NULL, at INTEGER NOT NULL, activity TEXT NOT NULL);
+    CREATE INDEX IF NOT EXISTS client_activity_scope ON client_activity_events(scope, session, sequence);
+    CREATE TABLE IF NOT EXISTS client_activity_snapshots(scope TEXT NOT NULL, session TEXT NOT NULL, sequence INTEGER NOT NULL, expired_through INTEGER NOT NULL DEFAULT 0, snapshot TEXT NOT NULL, PRIMARY KEY(scope,session));`);
+  const redaction = createRedactionPolicy({ includeEmails: true });
+  const redact = (text) => {
+    let result = text;
+    for (const secret of options.sensitiveValues ?? [])
+      if (secret)
+        result = result.split(secret).join("[REDACTED]");
+    return redaction.redactText(result).replace(/\b(?:sk|ghp|github_pat|xox[baprs])[-_][A-Za-z0-9_-]+/gi, "[REDACTED]");
+  };
+  const redactValue = (value) => typeof value === "string" ? redact(value) : Array.isArray(value) ? value.map(redactValue) : value && typeof value === "object" ? Object.fromEntries(Object.entries(value).map(([k, v]) => [k, redactValue(v)])) : value;
+  const tails = new Map;
+  const discard = new Set;
+  const flush = (key, chunk, final = false) => {
+    let text = (tails.get(key) ?? "") + chunk;
+    for (const secret of options.sensitiveValues ?? [])
+      if (secret)
+        text = text.split(secret).join("[REDACTED]");
+    if (discard.has(key)) {
+      const end = text.search(/\s/);
+      if (end < 0 && !final)
+        return "";
+      text = end < 0 ? "" : text.slice(end);
+      discard.delete(key);
+    }
+    let boundary = final ? text.length : text.match(/^[\s\S]*\s/)?.[0].length ?? 0;
+    if (!final)
+      for (const secret of options.sensitiveValues ?? []) {
+        if (!secret)
+          continue;
+        let start = text.indexOf(secret[0], Math.max(0, text.length - secret.length + 1));
+        while (start >= 0 && start < boundary) {
+          if (secret.startsWith(text.slice(start))) {
+            boundary = start;
+            break;
+          }
+          start = text.indexOf(secret[0], start + 1);
+        }
+      }
+    let result = redact(text.slice(0, boundary));
+    text = text.slice(boundary);
+    if (text.length > 16384) {
+      result += "[TRUNCATED]";
+      text = "";
+      discard.add(key);
+    }
+    tails.set(key, text);
+    return result;
+  };
+  const snapshot = (sessionId) => {
+    const row = db.query("SELECT snapshot,expired_through FROM client_activity_snapshots WHERE scope=? AND session=?").get(scope, sessionId);
+    return { state: row ? JSON.parse(row.snapshot) : { schemaVersion: 1, sessionId, sequence: 0, runs: {} }, expiredThrough: row?.expired_through ?? 0 };
+  };
+  const prune = () => {
+    const expired = db.query(`SELECT session,MAX(sequence) AS seq FROM client_activity_events WHERE scope=? AND (at < ? OR sequence NOT IN (SELECT sequence FROM client_activity_events WHERE scope=? ORDER BY sequence DESC LIMIT ?)) GROUP BY session`).all(scope, now() - retentionMs, scope, maxEvents);
+    for (const row of expired) {
+      db.query("UPDATE client_activity_snapshots SET expired_through=MAX(expired_through,?) WHERE scope=? AND session=?").run(row.seq, scope, row.session);
+      db.query("DELETE FROM client_activity_events WHERE scope=? AND session=? AND sequence<=?").run(scope, row.session, row.seq);
+    }
+  };
+  const write = (sessionId, runId, activity) => {
+    if (!/^[A-Za-z0-9._:-]{1,128}$/.test(sessionId) || !/^[A-Za-z0-9._:-]{1,128}$/.test(runId))
+      throw new Error("ACTIVITY_ID_INVALID");
+    const at = now();
+    const encoded = JSON.stringify(activity);
+    if (Buffer.byteLength(encoded) > 64 * 1024)
+      throw new Error("ACTIVITY_TOO_LARGE");
+    db.exec("BEGIN IMMEDIATE");
+    try {
+      const current = snapshot(sessionId).state;
+      const runs = Object.keys(current.runs);
+      if (!current.runs[runId] && runs.length >= 1000)
+        throw new Error("ACTIVITY_RUN_LIMIT");
+      const state = current.runs[runId] ?? { text: "", status: "running", truncated: false };
+      if (typeof activity.textDelta === "string") {
+        state.text += activity.textDelta;
+        if (state.text.length > 256 * 1024) {
+          state.text = state.text.slice(-256 * 1024);
+          state.truncated = true;
+        }
+      }
+      if (activity.type === "user-message" && typeof activity.prompt === "string")
+        state.prompt = activity.prompt;
+      if (typeof activity.toolCallId === "string" && typeof activity.toolName === "string") {
+        state.tools ??= {};
+        const key = `tool:${activity.toolCallId}`;
+        if (state.tools[key] || Object.keys(state.tools).length < 256) {
+          const status = activity.type === "tool-result" ? activity.isError === true || activity.timedOut === true || typeof activity.exitCode === "number" && activity.exitCode !== 0 ? "failed" : "completed" : "running";
+          state.tools[key] = { name: activity.toolName, status, ...typeof activity.exitCode === "number" ? { exitCode: activity.exitCode } : {}, ...typeof activity.timedOut === "boolean" ? { timedOut: activity.timedOut } : {} };
+        } else
+          state.truncated = true;
+      }
+      if (typeof activity.status === "string" && (activity.type === "checkpoint" || activity.type === "agent-run-finish"))
+        state.status = activity.status;
+      if (activity.type === "agent-run-start")
+        state.status = "running";
+      if (activity.type === "tool-approval-request" || activity.type === "agent-approval-request")
+        state.status = "waiting_approval";
+      current.runs[runId] = state;
+      if (Buffer.byteLength(JSON.stringify(current)) > 2 * 1024 * 1024)
+        throw new Error("ACTIVITY_SNAPSHOT_LIMIT");
+      db.query("INSERT INTO client_activity_events(scope,session,run,at,activity) VALUES(?,?,?,?,?)").run(scope, sessionId, runId, at, encoded);
+      current.sequence = db.query("SELECT last_insert_rowid() AS seq").get().seq;
+      db.query("INSERT INTO client_activity_snapshots(scope,session,sequence,snapshot) VALUES(?,?,?,?) ON CONFLICT(scope,session) DO UPDATE SET sequence=excluded.sequence,snapshot=excluded.snapshot").run(scope, sessionId, current.sequence, JSON.stringify(current));
+      prune();
+      db.exec("COMMIT");
+    } catch (e) {
+      db.exec("ROLLBACK");
+      throw e;
+    }
+  };
+  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;
+      write(sessionId, runId, { type: "user-message", prompt: truncated ? Buffer.from(safe).subarray(0, 60 * 1024).toString("utf8") + "[TRUNCATED]" : safe });
+    },
+    append(sessionId, runId, event) {
+      const key = `${sessionId}:${runId}`;
+      if (event.type === "text-delta") {
+        const textDelta = flush(key, event.textDelta);
+        if (textDelta)
+          write(sessionId, runId, { type: "text-delta", textDelta });
+        return;
+      }
+      if (event.type === "agent-run-finish" || event.type === "error") {
+        const textDelta = flush(key, "", true);
+        if (textDelta)
+          write(sessionId, runId, { type: "text-delta", textDelta });
+        tails.delete(key);
+      }
+      const projected = streamEventDocument(event);
+      if (projected) {
+        let receipt = {};
+        if (event.type === "tool-result" && event.toolResult.toolName === "run_check") {
+          const output = event.toolResult.output;
+          if (output && typeof output === "object" && !Array.isArray(output) && "exitCode" in output && Number.isSafeInteger(output.exitCode))
+            receipt = { exitCode: output.exitCode, timedOut: "timedOut" in output && output.timedOut === true };
+        }
+        write(sessionId, runId, redactValue({ ...projected, ...receipt }));
+      }
+    },
+    checkpoint(sessionId, runId, status) {
+      const key = `${sessionId}:${runId}`;
+      const textDelta = flush(key, "", true);
+      if (textDelta)
+        write(sessionId, runId, { type: "text-delta", textDelta });
+      tails.delete(key);
+      write(sessionId, runId, { type: "checkpoint", status });
+    },
+    replay(sessionId, after = 0) {
+      if (!Number.isSafeInteger(after) || after < 0)
+        throw new Error("ACTIVITY_CURSOR_INVALID");
+      db.exec("BEGIN IMMEDIATE");
+      try {
+        prune();
+        db.exec("COMMIT");
+      } catch (e) {
+        db.exec("ROLLBACK");
+        throw e;
+      }
+      const current = snapshot(sessionId);
+      const expired = after < current.expiredThrough;
+      if (after > current.state.sequence)
+        throw new Error("ACTIVITY_CURSOR_AHEAD");
+      if (expired)
+        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();
+      tails.clear();
+      discard.clear();
+    }
+  };
+};
+
+// src/client/local-service.ts
+import { createServer, request as httpRequest } from "node:http";
+import { randomBytes, timingSafeEqual, createHash as createHash2 } from "node:crypto";
+import { mkdir, lstat, realpath, open, unlink, chmod } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+var harnessLocalCredentialsSchema = z.object({ schemaVersion: z.literal(1), socketPath: z.string().min(1), token: z.string().regex(/^[a-f0-9]{64}$/) }).strict();
+var send = (response, status, document) => {
+  response.writeHead(status, { "content-type": "application/json", "cache-control": "no-store", "x-content-type-options": "nosniff", connection: "close" });
+  response.end(JSON.stringify(document));
+};
+var fault = (code) => ({ ok: false, error: { code } });
+var body = async (request) => {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of request) {
+    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += bytes.length;
+    if (size > 128 * 1024)
+      throw new Error("REQUEST_TOO_LARGE");
+    chunks.push(bytes);
+  }
+  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+};
+var privateFile = async (filename, data) => {
+  const file = await open(filename, "wx", 384);
+  try {
+    await file.writeFile(data);
+    await file.sync();
+  } finally {
+    await file.close();
+  }
+};
+var exists = async (filename) => {
+  try {
+    return await lstat(filename);
+  } catch (e) {
+    if (e.code === "ENOENT")
+      return;
+    throw e;
+  }
+};
+var startHarnessLocalService = async (harness, options) => {
+  if (process.platform === "win32")
+    throw new Error("LOCAL_SERVICE_PLATFORM_UNSUPPORTED");
+  const directory = path.resolve(options.directory);
+  await mkdir(directory, { recursive: true, mode: 448 });
+  const info = await lstat(directory);
+  if (!info.isDirectory() || info.isSymbolicLink() || (info.mode & 63) !== 0 || info.uid !== process.getuid?.())
+    throw new Error("LOCAL_SERVICE_DIRECTORY_UNSAFE");
+  const canonicalDirectory = await realpath(directory);
+  const workspaceIdentity = createHash2("sha256").update(JSON.stringify([harness.config.workspace, harness.config.scope])).digest("hex").slice(0, 20);
+  const socketPath = path.join(canonicalDirectory, `${workspaceIdentity}.sock`);
+  if (Buffer.byteLength(socketPath) > 100)
+    throw new Error("LOCAL_SERVICE_SOCKET_PATH_TOO_LONG");
+  const credentialsPath = path.join(canonicalDirectory, `${workspaceIdentity}.json`);
+  const lockPath = path.join(canonicalDirectory, `${workspaceIdentity}.lock`);
+  const token = randomBytes(32).toString("hex");
+  await privateFile(lockPath, JSON.stringify({ schemaVersion: 1, pid: process.pid }));
+  let adapter;
+  let activity;
+  const pending = new Set;
+  let closing = false, paused = false, activeMutations = 0, closePromise;
+  const server = createServer((req, res) => {
+    const operation = (async () => {
+      const actual = Buffer.from(req.headers.authorization ?? "");
+      const expected = Buffer.from(`Bearer ${token}`);
+      if (actual.length !== expected.length || !timingSafeEqual(actual, expected))
+        return send(res, 401, fault("UNAUTHORIZED"));
+      if (req.headers.origin !== undefined || req.headers["sec-fetch-site"] !== undefined)
+        return send(res, 403, fault("ORIGIN_REJECTED"));
+      if (closing)
+        return send(res, 503, fault("SERVICE_CLOSING"));
+      if (req.method === "GET" && req.url === "/health")
+        return send(res, 200, { ok: true, schemaVersion: 1, status: "ready" });
+      if (req.method !== "POST" || !["/hello", "/command", "/events"].includes(req.url ?? ""))
+        return send(res, 404, fault("NOT_FOUND"));
+      if (req.headers["content-type"] !== "application/json")
+        return send(res, 415, fault("CONTENT_TYPE_REQUIRED"));
+      let value;
+      try {
+        value = await body(req);
+      } catch {
+        return send(res, 400, fault("INVALID_REQUEST"));
+      }
+      if (closing)
+        return send(res, 503, fault("SERVICE_CLOSING"));
+      if (req.url === "/hello") {
+        const parsed2 = z.object({ versions: z.array(z.number().int()).min(1).max(16) }).strict().safeParse(value);
+        return send(res, 200, parsed2.success ? adapter.negotiate(parsed2.data.versions) : fault("INVALID_REQUEST"));
+      }
+      if (req.url === "/events") {
+        const parsed2 = z.object({ projectId: z.string(), sessionId: z.string().regex(/^[A-Za-z0-9._:-]{1,128}$/), after: z.number().int().nonnegative().safe().optional() }).strict().safeParse(value);
+        const hello = adapter.negotiate([1]);
+        if (!parsed2.success)
+          return send(res, 400, fault("INVALID_REQUEST"));
+        if (!hello.ok || parsed2.data.projectId !== hello.projectId)
+          return send(res, 404, fault("NOT_FOUND"));
+        try {
+          return send(res, 200, activity.replay(parsed2.data.sessionId, parsed2.data.after));
+        } catch {
+          return send(res, 400, fault("INVALID_CURSOR"));
+        }
+      }
+      const parsed = harnessClientRequestSchema.safeParse(value);
+      const method = parsed.success ? parsed.data.command.method : undefined;
+      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)
+        activeMutations++;
+      try {
+        return send(res, 200, await adapter.dispatch(value));
+      } finally {
+        if (mutation)
+          activeMutations--;
+      }
+    })().catch(() => {
+      if (!res.headersSent)
+        send(res, 500, fault("EXECUTION_FAILED"));
+      else
+        res.destroy();
+    });
+    pending.add(operation);
+    operation.finally(() => pending.delete(operation));
+  });
+  server.requestTimeout = Math.max(30000, harness.config.timeoutMs + 1e4);
+  server.headersTimeout = 1e4;
+  server.keepAliveTimeout = 1000;
+  let ownsSocket = false, ownsCredentials = false;
+  const cleanup = async () => {
+    if (ownsSocket)
+      await unlink(socketPath).catch((e) => {
+        if (e.code !== "ENOENT")
+          throw e;
+      });
+    if (ownsCredentials)
+      await unlink(credentialsPath).catch((e) => {
+        if (e.code !== "ENOENT")
+          throw e;
+      });
+    await unlink(lockPath);
+  };
+  try {
+    if (await exists(socketPath) || await exists(credentialsPath))
+      throw new Error("LOCAL_SERVICE_STALE_STATE");
+    activity = await openHarnessActivityStore(harness.config, {
+      sensitiveValues: [token, ...options.sensitiveValues ?? [], ...Object.entries(process.env).filter(([k, v]) => /(?:API_KEY|TOKEN|SECRET|PASSWORD)$/.test(k) && v && v.length >= 8).map(([, v]) => v)],
+      ...options.maxEvents === undefined ? {} : { maxEvents: options.maxEvents },
+      ...options.retentionMs === undefined ? {} : { retentionMs: options.retentionMs }
+    });
+    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)
+    });
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(socketPath, () => {
+        server.off("error", reject);
+        resolve();
+      });
+    });
+    ownsSocket = true;
+    await chmod(socketPath, 384);
+    await privateFile(credentialsPath, JSON.stringify({ schemaVersion: 1, socketPath, token }));
+    ownsCredentials = true;
+    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");
+        paused = true;
+        return activeMutations > 0;
+      },
+      resumeAdmission() {
+        if (closing)
+          throw new Error("SERVICE_CLOSING");
+        paused = false;
+      },
+      cancelActive() {
+        return adapter.cancelActive();
+      },
+      close() {
+        closePromise ??= (async () => {
+          closing = true;
+          const stopped = new Promise((resolve, reject) => server.close((e) => e ? reject(e) : resolve()));
+          await Promise.allSettled([...pending]);
+          await stopped;
+          adapter.close();
+          activity.close();
+          await harness.close();
+          await cleanup();
+        })();
+        return closePromise;
+      }
+    };
+  } catch (e) {
+    if (server.listening)
+      await new Promise((resolve) => server.close(() => resolve()));
+    adapter?.close();
+    activity?.close();
+    await cleanup();
+    throw e;
+  }
+};
+var readHarnessLocalCredentials = async (filename) => {
+  const { constants } = await import("node:fs");
+  const file = await open(filename, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const info = await file.stat();
+    if (!info.isFile() || (info.mode & 63) !== 0 || info.uid !== process.getuid?.() || info.size > 4096)
+      throw new Error("LOCAL_SERVICE_CREDENTIALS_UNSAFE");
+    return harnessLocalCredentialsSchema.parse(JSON.parse(await file.readFile("utf8")));
+  } finally {
+    await file.close();
+  }
+};
+var requestHarnessLocalService = async (credentials, endpoint, payload) => {
+  const parsed = harnessLocalCredentialsSchema.parse(credentials);
+  if (!path.isAbsolute(parsed.socketPath) || process.platform === "win32")
+    throw new Error("LOCAL_SERVICE_SOCKET_INVALID");
+  const encoded = JSON.stringify(payload);
+  if (Buffer.byteLength(encoded) > 131072)
+    throw new Error("REQUEST_TOO_LARGE");
+  return new Promise((resolve, reject) => {
+    const req = httpRequest({ socketPath: parsed.socketPath, path: `/${endpoint}`, method: "POST", headers: {
+      authorization: `Bearer ${parsed.token}`,
+      "content-type": "application/json",
+      "content-length": Buffer.byteLength(encoded)
+    } }, (res) => {
+      const chunks = [];
+      let size = 0;
+      res.on("data", (chunk) => {
+        size += chunk.length;
+        if (size > 4194304)
+          res.destroy(new Error("RESPONSE_TOO_LARGE"));
+        else
+          chunks.push(chunk);
+      });
+      res.on("error", reject);
+      res.on("end", () => {
+        try {
+          if (res.statusCode !== 200)
+            return reject(new Error(`LOCAL_SERVICE_HTTP_${res.statusCode}`));
+          resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+        } catch {
+          reject(new Error("LOCAL_SERVICE_RESPONSE_INVALID"));
+        }
+      });
+    });
+    req.on("error", () => reject(new Error("LOCAL_SERVICE_UNAVAILABLE")));
+    req.end(encoded);
+  });
+};
+var recoverHarnessLocalService = async (harness, directory) => {
+  const info = await lstat(directory);
+  if (!info.isDirectory() || info.isSymbolicLink() || (info.mode & 63) !== 0 || info.uid !== process.getuid?.())
+    throw new Error("LOCAL_SERVICE_DIRECTORY_UNSAFE");
+  const root = await realpath(directory);
+  const identity = createHash2("sha256").update(JSON.stringify([harness.config.workspace, harness.config.scope])).digest("hex").slice(0, 20);
+  const lockPath = path.join(root, `${identity}.lock`);
+  const index = await openCliSessionStore({ workspace: harness.config.workspace, stateDirectory: harness.config.stateDirectory, scope: harness.config.scope, busyTimeoutMs: 0 });
+  const databasePath = index.databasePath;
+  index.close();
+  const db = new SqliteDatabase(databasePath);
+  let locked = false;
+  try {
+    db.exec("PRAGMA busy_timeout = 0");
+    db.exec("BEGIN IMMEDIATE");
+    locked = true;
+    const { constants } = await import("node:fs");
+    const handle = await open(lockPath, constants.O_RDONLY | constants.O_NOFOLLOW);
+    let owner;
+    try {
+      const stat = await handle.stat();
+      if (!stat.isFile() || stat.uid !== process.getuid?.() || (stat.mode & 63) !== 0 || stat.size > 4096)
+        throw new Error("LOCAL_SERVICE_LOCK_UNSAFE");
+      owner = z.object({ schemaVersion: z.literal(1), pid: z.number().int().positive().max(2147483647) }).strict().parse(JSON.parse(await handle.readFile("utf8")));
+    } finally {
+      await handle.close();
+    }
+    try {
+      process.kill(owner.pid, 0);
+      throw new Error("LOCAL_SERVICE_OWNER_ALIVE");
+    } catch (e) {
+      if (e.code !== "ESRCH")
+        throw e;
+    }
+    for (const extension of ["sock", "json"]) {
+      const filename = path.join(root, `${identity}.${extension}`);
+      const entry = await exists(filename);
+      if (!entry)
+        continue;
+      if (entry.isSymbolicLink() || entry.uid !== process.getuid?.() || (entry.mode & 63) !== 0 || (extension === "sock" ? !entry.isSocket() : !entry.isFile()))
+        throw new Error("LOCAL_SERVICE_RECOVERY_UNSAFE");
+    }
+    for (const extension of ["sock", "json"])
+      await unlink(path.join(root, `${identity}.${extension}`)).catch((e) => {
+        if (e.code !== "ENOENT")
+          throw e;
+      });
+    await unlink(lockPath);
+    db.exec("COMMIT");
+    locked = false;
+  } finally {
+    try {
+      if (locked)
+        db.exec("ROLLBACK");
+    } finally {
+      db.close();
+    }
+  }
+};
+
+export { openHarnessActivityStore, harnessLocalCredentialsSchema, startHarnessLocalService, readHarnessLocalCredentials, requestHarnessLocalService, recoverHarnessLocalService };