@peakflo/agent-harness 0.2.8 → 0.2.9-rc.2

package/dist/options.js

@@ -150,6 +150,17 @@ function parseBoolean(raw, fallback, name) {
         return false;
     throw new OptionsError(`Invalid ${name}: '${raw}'. Expected true or false.`);
 }
+/** An on/off variable: 1/true/on/yes or 0/false/off/no. A typo fails the start. */
+function parseSwitch(raw, fallback, name) {
+    if (raw === undefined || raw.trim() === '')
+        return fallback;
+    const value = raw.trim().toLowerCase();
+    if (['1', 'true', 'on', 'yes'].includes(value))
+        return true;
+    if (['0', 'false', 'off', 'no'].includes(value))
+        return false;
+    throw new OptionsError(`Invalid ${name}: '${raw}'. Expected 1 or 0.`);
+}
 /**
  * Flags win over environment variables, so a local developer can override a
  * value that pf-bootstrap injected.
@@ -207,6 +218,11 @@ function parseOptions(argv, env) {
             defaultWorkspaceRoot(),
         runtime,
         maxConcurrentSessions: parseConcurrency(readFlag(argv, 'max-sessions') ?? env.PF_MAX_CONCURRENT_SESSIONS, runtime),
-        labels: parseLabels(readFlag(argv, 'labels') ?? env.PF_RUNNER_LABELS)
+        labels: parseLabels(readFlag(argv, 'labels') ?? env.PF_RUNNER_LABELS),
+        // The flag wins over the environment, so one start can turn it off
+        // without editing a service file.
+        harnessDiscovery: readBoolFlag(argv, 'no-harness-discovery')
+            ? false
+            : parseSwitch(env.PF_HARNESS_DISCOVERY, true, 'harness discovery flag (PF_HARNESS_DISCOVERY)')
     };
 }

package/dist/store/conversation-store.js

@@ -27,6 +27,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemoryConversationStore = exports.SqliteConversationStore = void 0;
 exports.openConversationStore = openConversationStore;
+const sqlite_store_1 = require("./sqlite-store");
 const SCHEMA = `
   CREATE TABLE IF NOT EXISTS model_messages (
     session_id TEXT NOT NULL,
@@ -292,6 +293,7 @@ function openConversationStore(path) {
         };
     }
     try {
+        (0, sqlite_store_1.ensureStoreDirectory)(path);
         const db = new sqlite.DatabaseSync(path);
         return { store: new SqliteConversationStore(db), durable: true };
     }

package/dist/store/sqlite-store.d.ts

@@ -106,6 +106,23 @@ export interface OpenStoreResult {
     /** Why durability was unavailable. Reported so a degraded fleet is visible. */
     reason?: string;
 }
+/**
+ * Make the directory a store file goes in, when it is not there yet.
+ *
+ * sqlite creates the FILE and never the directory: a `--workspace-root` that
+ * does not exist yet made every open fail with "unable to open database
+ * file", and the runner then ran in memory and reported itself degraded —
+ * for a path it was about to create anyway on the first session. Private
+ * mode, because the stores hold transcripts and the model's conversation.
+ *
+ * A directory that ALREADY EXISTS is left exactly as it is, its mode included:
+ * `mkdir` with `recursive` does not touch one, and changing the permissions
+ * of a directory somebody chose is not this function's call.
+ *
+ * Throws when the directory cannot be made; the caller turns that into the
+ * same visible memory fallback as any other open failure.
+ */
+export declare function ensureStoreDirectory(path: string): void;
 /**
  * Open the durable store, or say plainly why it could not be opened.
  *

package/dist/store/sqlite-store.js

@@ -32,7 +32,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemoryTranscriptStore = exports.SqliteTranscriptStore = void 0;
+exports.ensureStoreDirectory = ensureStoreDirectory;
 exports.openTranscriptStore = openTranscriptStore;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const SCHEMA = `
   CREATE TABLE IF NOT EXISTS transcript_parts (
     session_id TEXT NOT NULL,
@@ -309,6 +312,28 @@ class MemoryTranscriptStore {
     }
 }
 exports.MemoryTranscriptStore = MemoryTranscriptStore;
+/**
+ * Make the directory a store file goes in, when it is not there yet.
+ *
+ * sqlite creates the FILE and never the directory: a `--workspace-root` that
+ * does not exist yet made every open fail with "unable to open database
+ * file", and the runner then ran in memory and reported itself degraded —
+ * for a path it was about to create anyway on the first session. Private
+ * mode, because the stores hold transcripts and the model's conversation.
+ *
+ * A directory that ALREADY EXISTS is left exactly as it is, its mode included:
+ * `mkdir` with `recursive` does not touch one, and changing the permissions
+ * of a directory somebody chose is not this function's call.
+ *
+ * Throws when the directory cannot be made; the caller turns that into the
+ * same visible memory fallback as any other open failure.
+ */
+function ensureStoreDirectory(path) {
+    // sqlite's in-memory and temporary databases have no directory.
+    if (path === ':memory:' || path === '')
+        return;
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(path), { recursive: true, mode: 0o700 });
+}
 /**
  * Open the durable store, or say plainly why it could not be opened.
  *
@@ -333,6 +358,7 @@ function openTranscriptStore(path) {
         };
     }
     try {
+        ensureStoreDirectory(path);
         const db = new sqlite.DatabaseSync(path);
         return { store: new SqliteTranscriptStore(db), durable: true };
     }

package/dist/types.d.ts

@@ -88,6 +88,13 @@ export interface HarnessOptions {
     maxConcurrentSessions: number;
     /** Free-form routing labels, e.g. ['eu-only', 'has-vpn']. */
     labels?: string[];
+    /**
+     * Look for the coding harnesses installed on this machine and report them.
+     * Defaults to true. `--no-harness-discovery` or `PF_HARNESS_DISCOVERY=0`
+     * turns it off: no harness CLI is started and no list is reported. A
+     * sandbox runner never runs discovery, whatever this says.
+     */
+    harnessDiscovery?: boolean;
 }
 /**
  * Every request body in this contract carries the protocol version, so the
@@ -223,6 +230,73 @@ export interface RunnerCapabilities {
      * serves `knowledge_files_list` / `knowledge_file_download`.
      */
     features?: string[];
+    /**
+     * Coding harnesses FOUND on this host, whether or not this runner can drive
+     * them. Reported by `harness-discovery.ts`.
+     *
+     * DETECTION IS NOT TURN SUPPORT. `backends` stays the only list the control
+     * plane routes on; an entry here with `runnable: false` is information for a
+     * person ("Codex is installed on this machine") and never a promise.
+     *
+     * OPTIONAL AND ADDITIVE, so no protocol bump: an older control plane stores
+     * the field and ignores it, and an older harness simply never sends it.
+     * Absent on a sandbox runner, which skips discovery altogether.
+     */
+    harnesses?: RunnerHarness[];
+    /**
+     * A short tag for the content of `harnesses`. Sent on EVERY capability
+     * report of a runner that runs discovery, also when the list itself is left
+     * out because the control plane already has it (see
+     * `RunnerHeartbeatResponse.harnessesDigest`).
+     */
+    harnessesDigest?: string;
+}
+/** Where a harness's model list came from. */
+export type RunnerHarnessModelSource = 
+/** Asked the harness CLI (`cursor-agent models`, `opencode models`). */
+'cli'
+/** Read from the harness's own model cache file. */
+ | 'config'
+/** A list compiled into this harness build, as 20x does. */
+ | 'static'
+/** The runnable backend's own probe (`backends[].models`). */
+ | 'backend';
+export interface RunnerHarnessModel {
+    id: string;
+    name: string;
+    /** The model the harness would use when none is named. */
+    default?: boolean;
+}
+/** One known coding harness, as found on this host. */
+export interface RunnerHarness {
+    /** 'codex' | 'claude-code' | 'cursor' | 'pi' | 'opencode' — the 20x names. */
+    name: string;
+    /** Display name, e.g. 'Claude Code'. */
+    label: string;
+    installed: boolean;
+    version?: string | null;
+    /** Installed, answering, and signed in. */
+    usable: boolean;
+    /**
+     * Why `usable` is false. ALWAYS one of a fixed set of sentences written in
+     * `harness-discovery.ts` — never text a CLI printed, so it cannot carry an
+     * account name or a token.
+     */
+    reason?: string;
+    /**
+     * The check of this harness DID NOT FINISH (it timed out), so `usable:
+     * false` here is not a statement about the harness. The runner checks again
+     * shortly. Only ever sent with `installed: true, usable: false`. A reader
+     * that does not know this field shows the entry as not usable with its
+     * reason, which says the same thing in words.
+     */
+    transient?: boolean;
+    /** This runner can run a turn with it: it is also listed in `backends`. */
+    runnable: boolean;
+    models?: RunnerHarnessModel[];
+    modelSource?: RunnerHarnessModelSource;
+    /** ISO time of the discovery pass that first found this state. */
+    detectedAt: string;
 }
 export interface RunnerBackend {
     /** 'opencode' | 'claude-code' | 'codex' | 'acp' | ... — an open vocabulary. */
@@ -319,6 +393,15 @@ export interface RunnerHeartbeatResponse {
      */
     action?: 'none' | 'drain' | 'restart';
     heartbeatIntervalMs?: number;
+    /**
+     * The `capabilities.harnessesDigest` the control plane has stored after
+     * this heartbeat. When it equals the runner's own, the runner leaves the
+     * (large) `harnesses` list out of the next heartbeat. ABSENT from an older
+     * control plane, and the runner then sends the list every time, which is
+     * the only thing that is correct there: an older control plane replaces
+     * `capabilities` as a whole on each heartbeat.
+     */
+    harnessesDigest?: string;
     /**
      * The outbound-only answer to "how does anything reach a running session?".
      * The control plane cannot dial in, so an abort or a user's answer to a

package/dist/version.d.ts

@@ -1,5 +1,7 @@
 /** The version of THIS package, as installed. */
 export declare function getHarnessVersion(): string;
+/** `engines.node` of THIS package (e.g. `>=22.19`), or null when unreadable. */
+export declare function getNodeFloor(): string | null;
 /**
  * The version of the SANDBOX TOOLS layer (gh, @peculiar/x509, ...) currently
  * installed, or null when nothing was ever synced — a self-hosted runner or

package/dist/version.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getHarnessVersion = getHarnessVersion;
+exports.getNodeFloor = getNodeFloor;
 exports.getInstalledSandboxToolsVersion = getInstalledSandboxToolsVersion;
 exports.getAttemptedSandboxToolsVersion = getAttemptedSandboxToolsVersion;
 exports.getPiVersion = getPiVersion;
@@ -23,6 +24,16 @@ function getHarnessVersion() {
     }
     return cachedHarnessVersion;
 }
+/** `engines.node` of THIS package (e.g. `>=22.19`), or null when unreadable. */
+function getNodeFloor() {
+    try {
+        const pkg = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, '..', 'package.json'), 'utf8'));
+        return typeof pkg.engines?.node === 'string' ? pkg.engines.node : null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * The version of the SANDBOX TOOLS layer (gh, @peculiar/x509, ...) currently
  * installed, or null when nothing was ever synced — a self-hosted runner or

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peakflo/agent-harness",
-  "version": "0.2.8",
+  "version": "0.2.9-rc.2",
   "description": "Headless Peakflo coding-agent harness. One codebase, three hosting modes: a Daytona cloud sandbox, a customer VM, and the 20x desktop.",
   "license": "MIT",
   "type": "commonjs",