@ahpd/server 0.1.0 → 0.3.0

package/dist/main.js

@@ -0,0 +1,335 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { automationsPath, configPath, loadConfig } from './config.js';
+import { running, start, stop as stopDaemon } from './daemon.js';
+import { pty } from './pty.js';
+import { claude } from '@ahpd/agent-claude';
+import { createHost, fileResources, gitBranches, gitChanges, gitWorktrees, hostTools, listen, memoryAutomations, scheduledAutomations, shellTerminals } from '@ahpd/sdk';
+const USAGE = `ahpd - an Agent Host Protocol server, with a Claude backend
+
+  ahpd [options]              run it here, in this terminal
+  ahpd start [options]        run it in the background and let go of it
+  ahpd stop                   stop the one running in the background
+  ahpd status                 say whether one is, and where
+  ahpd config                 say where the configuration is, and what it says
+
+  --port <n>                    Listen here. Default 9187; 0 picks a free one.
+  --host <addr>                 Bind here. Default 127.0.0.1. Pass 0.0.0.0 to
+                                accept from other machines, which needs a token.
+  --path <dir>                  A directory this host serves. Repeatable; the
+                                first is the default a client gets when it
+                                names none, and a directory not named here is
+                                refused. Default: where the daemon started.
+  --connection-token <secret>   Require this secret on every connection.
+  --connection-token-file <p>   Require the secret in this file. A fresh one is
+                                written if the file is not there.
+  --without-connection-token    Accept any connection. Only when the port is
+                                already reachable by nobody else.
+  --config-file <p>             Read this instead of the file below.
+  --automations <where>         file, the default, keeps them beside the
+                                configuration and fires their schedules;
+                                memory keeps them until this process ends and
+                                fires nothing.
+  --help, -h                    This
+
+Every option above can be a key in the configuration file instead, spelled the
+way it is here without the dashes: port, host, paths, connectionToken,
+connectionTokenFile, withoutConnectionToken, automations. A flag beats the file, because a
+flag is this run and a file is every run until somebody edits it.
+
+Clients present the token as ?tkn=<secret> on the URL, or as an
+Authorization: Bearer <secret> header.
+
+Point a client at it:
+  ahpc --host ws://127.0.0.1:9187
+`;
+function parse(argv) {
+    const options = {
+        port: 9187,
+        host: '127.0.0.1',
+        paths: [],
+        automations: 'file',
+        open: false,
+        help: false,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        switch (argv[i]) {
+            case '--port':
+                options.port = Number(argv[++i]);
+                break;
+            case '--host':
+                options.host = String(argv[++i]);
+                break;
+            // Repeatable. One host over two projects is one catalogue and one
+            // process, which is the case a second `--path` is for; a directory this
+            // host was not told about is refused rather than served, because a host
+            // that ran the agent wherever it was told is one anybody who can reach
+            // the port can point at any directory on the machine.
+            case '--path':
+                options.paths.push(String(argv[++i]));
+                break;
+            case '--connection-token':
+                options.token = String(argv[++i]);
+                break;
+            case '--connection-token-file':
+                options.tokenFile = String(argv[++i]);
+                break;
+            case '--without-connection-token':
+                options.open = true;
+                break;
+            case '--config-file':
+                options.configFile = String(argv[++i]);
+                break;
+            case '--automations': {
+                const said = String(argv[++i]);
+                if (said === 'file' || said === 'memory')
+                    options.automations = said;
+                else
+                    stop(`--automations takes file or memory, not ${said}.`);
+                break;
+            }
+            case '--help':
+            case '-h':
+                options.help = true;
+                break;
+            default:
+                if (argv[i]?.startsWith('-')) {
+                    process.stderr.write(`Unknown option ${argv[i]}. Try --help.\n`);
+                    process.exit(2);
+                }
+        }
+    }
+    /*
+     * The file, under the flags.
+     *
+     * Each source is narrower than the one below it: a flag is this run and a
+     * file is every run until somebody edits it, so the flag wins. `paths` is
+     * replaced rather than merged - a file that named two directories and a
+     * `--path` that named a third would otherwise serve three, which is not
+     * what either of them said.
+     */
+    const file = loadConfig(options.configFile);
+    if (!argv.includes('--port') && typeof file.port === 'number')
+        options.port = file.port;
+    if (!argv.includes('--host') && typeof file.host === 'string')
+        options.host = file.host;
+    if (options.paths.length === 0 && Array.isArray(file.paths))
+        options.paths.push(...file.paths);
+    if (options.token === undefined && typeof file.connectionToken === 'string')
+        options.token = file.connectionToken;
+    if (options.tokenFile === undefined && typeof file.connectionTokenFile === 'string')
+        options.tokenFile = file.connectionTokenFile;
+    if (!options.open && file.withoutConnectionToken === true)
+        options.open = true;
+    if (!argv.includes('--automations') && (file.automations === 'file' || file.automations === 'memory')) {
+        options.automations = file.automations;
+    }
+    if (options.paths.length === 0)
+        options.paths.push(process.cwd());
+    return options;
+}
+const stop = (message) => {
+    process.stderr.write(`${message}\n`);
+    process.exit(2);
+};
+/**
+ * The secret this host will require, and where it came from.
+ *
+ * A token file that is not there is written rather than refused: the flag is
+ * how a supervisor points several processes at one secret, and requiring the
+ * person to invent one first makes the convenient spelling the unusable one.
+ */
+function secret(options) {
+    if (options.open) {
+        if (options.token !== undefined || options.tokenFile !== undefined) {
+            stop('--without-connection-token contradicts the token you also passed.');
+        }
+        return { from: 'no token: any connection is accepted' };
+    }
+    if (options.token !== undefined && options.tokenFile !== undefined) {
+        stop('Pass --connection-token or --connection-token-file, not both.');
+    }
+    if (options.token !== undefined) {
+        if (options.token === '')
+            stop('--connection-token was empty.');
+        return { token: options.token, from: 'token: from --connection-token' };
+    }
+    if (options.tokenFile !== undefined) {
+        if (existsSync(options.tokenFile)) {
+            const held = readFileSync(options.tokenFile, 'utf8').trim();
+            if (held === '')
+                stop(`${options.tokenFile} is empty.`);
+            return { token: held, from: `token: read from ${options.tokenFile}` };
+        }
+        const made = crypto.randomUUID().replaceAll('-', '');
+        // Owner-only, because the file is the credential.
+        writeFileSync(options.tokenFile, `${made}\n`, { mode: 0o600 });
+        return { token: made, from: `token: written to ${options.tokenFile}` };
+    }
+    // Loopback needs no secret - anything reaching it is already on this
+    // machine. Any other address does, and starting without one there would be
+    // a host on the network that anybody can drive.
+    const loopback = options.host === '127.0.0.1' || options.host === '::1' || options.host === 'localhost';
+    if (!loopback) {
+        stop(`Binding ${options.host} exposes this host beyond this machine.\n`
+            + 'Pass --connection-token, --connection-token-file, or --without-connection-token.');
+    }
+    return { from: 'no token: loopback only' };
+}
+const argv = process.argv.slice(2);
+/*
+ * The subcommands, which are about a daemon rather than being one.
+ *
+ * Answered before anything is built: `stop` and `status` need no host, and
+ * `start` is this same program run again with the rest of the line. Keeping
+ * them here means there is one place that knows how to read these options,
+ * and `start` cannot drift from what it starts.
+ */
+const verb = argv[0] !== undefined && !argv[0].startsWith('-') ? argv[0] : undefined;
+if (verb !== undefined) {
+    const rest = argv.slice(1);
+    if (verb === 'start') {
+        // Parsed here as well as by the child, so a bad option is refused now
+        // rather than by something that has already been let go of.
+        parse(rest);
+        try {
+            const begun = await start(rest, process.argv[1]);
+            process.stdout.write(`ahpd on ${begun.url} (pid ${String(begun.pid)}), sessions in ${begun.paths.join(', ') || process.cwd()}\n`);
+            if (begun.automations !== undefined)
+                process.stdout.write(`automations ${begun.automations}\n`);
+            process.exit(0);
+        }
+        catch (error) {
+            process.stderr.write(`Could not start it: ${error instanceof Error ? error.message : String(error)}\n`);
+            process.exit(1);
+        }
+    }
+    if (verb === 'stop') {
+        const stopped = stopDaemon();
+        process.stdout.write(stopped ? `Stopped ${stopped.url} (pid ${String(stopped.pid)}).\n` : 'None running.\n');
+        process.exit(stopped ? 0 : 1);
+    }
+    if (verb === 'status') {
+        const found = running();
+        if (!found) {
+            process.stdout.write('None running.\n');
+            process.exit(1);
+        }
+        process.stdout.write(`ahpd on ${found.url} (pid ${String(found.pid)}), started ${found.startedAt}\n`);
+        if (found.paths.length > 0)
+            process.stdout.write(`sessions in ${found.paths.join(', ')}\n`);
+        // Absent from a record written by an older daemon, which is the one case
+        // where saying nothing is better than guessing which store it was given.
+        if (found.automations !== undefined)
+            process.stdout.write(`automations ${found.automations}\n`);
+        process.exit(0);
+    }
+    if (verb === 'config') {
+        const at = argv.includes('--config-file') ? argv[argv.indexOf('--config-file') + 1] : configPath();
+        process.stdout.write(`${at}\n`);
+        const found = loadConfig(argv.includes('--config-file') ? at : undefined);
+        const rows = Object.entries(found);
+        process.stdout.write(rows.length === 0
+            ? '  (nothing set)\n'
+            : `${rows.map(([key, value]) => `  ${key}: ${JSON.stringify(value)}`).join('\n')}\n`);
+        process.exit(0);
+    }
+    process.stderr.write(`No command called ${verb}. Try --help.\n`);
+    process.exit(2);
+}
+const options = parse(argv);
+if (options.help) {
+    process.stdout.write(USAGE);
+    process.exit(0);
+}
+const { token, from } = secret(options);
+/*
+ * Whether a clock is running, decided once and then said out loud.
+ *
+ * Both stores take a schedule trigger and only one of them ever fires it, and
+ * what tells a client which it got is a `nextRunAt` that is simply absent.
+ * That is too quiet for somebody who has just written a schedule, so the
+ * startup line says it in words and `ahpd status` repeats it.
+ */
+const memory = options.automations === 'memory';
+const host = createHost({
+    path: options.paths[0],
+    // The daemon serves Claude Code. The host serves whatever it is given -
+    // see `examples/` for what a second one looks like.
+    agents: [claude({ paths: options.paths })],
+    /*
+     * What this daemon can do that the protocol cannot.
+     *
+     * All three touch the machine - a file, a subprocess, a `git` binary - and
+     * all three are handed in rather than reached for, so `createHost` stays the
+     * protocol and nothing else. A host embedded somewhere with its own notion
+     * of a file passes its own; one with no shell passes no terminals and says
+     * `-32601` when asked for one.
+     */
+    resources: fileResources(),
+    terminals: shellTerminals(await pty()),
+    directories: gitBranches(),
+    changes: gitChanges(),
+    worktrees: gitWorktrees(),
+    /*
+     * The host's own tools, offered to every session's model.
+     *
+     * What a session cannot see from inside itself: the sessions running beside
+     * it and the terminals the person has open. Both read-only, and both facts
+     * only the host has.
+     */
+    tools: hostTools(),
+    /*
+     * Automations, with a clock unless asked otherwise.
+     *
+     * A daemon is the case the port was written for: it is already running at
+     * nine in the morning, which is the only way an automation fires with
+     * nobody connected. Definitions live in a file beside the configuration and
+     * come back on a restart; the runs do not, because they name sessions that
+     * went when the process did.
+     *
+     * `--automations memory` is the same store without either half: nothing is
+     * written and nothing fires. Both are an `AutomationStore`, so the host is
+     * not told which it was given - a host embedded in something that already
+     * schedules passes a third of its own.
+     */
+    automations: memory
+        ? memoryAutomations()
+        : scheduledAutomations({
+            // Beside the configuration, which is this daemon's decision to make and
+            // not the store's - see `ScheduledOptions.file`.
+            file: automationsPath(),
+            onProblem: (message) => process.stdout.write(`${message}\n`),
+        }),
+    /*
+     * When, as well as what.
+     *
+     * The daemon's own lines had no times on them, so a log read after
+     * something went wrong said what happened in order and nothing about how
+     * far apart - which is most of what is worth knowing when a process died
+     * a minute after starting. It is also what makes this log line up against
+     * a client's, since the two are separate programs and the only thing they
+     * share is a clock.
+     *
+     * The timestamp is added here rather than in `createHost`, because a host
+     * embedded in something else has its own log with its own format and
+     * `onEvent` hands it the message to do that with.
+     */
+    onEvent: (message) => process.stdout.write(`${new Date().toISOString()} ${message}\n`),
+});
+// Whichever runtime this is. `listen` is the only file that knows, and it
+// says which one it found - a daemon that silently ran somewhere unexpected
+// would be a daemon nobody could tell apart from the one they meant to start.
+const listener = await listen({ port: options.port, host: options.host, ...(token !== undefined ? { token } : {}) }, (peer) => host.accept(peer));
+process.stdout.write(`ahpd on ws://${listener.host}:${listener.port} (${listener.runtime}), sessions in ${options.paths.join(', ')}\n`
+    // Its own line rather than the end of the one above, which `daemon.ts`
+    // reads the session directories off with a regular expression.
+    + `automations ${memory ? 'in memory, schedules do not fire' : `in ${automationsPath()}, schedules fire`}\n`
+    // Where the secret came from, never the secret: stdout is a log, and a log
+    // is the one place a credential should not end up.
+    + `${from}\n`);
+const shutdown = () => {
+    void Promise.resolve(listener.close()).finally(() => process.exit(0));
+};
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);

package/dist/pty.d.ts

@@ -0,0 +1,12 @@
+/** The optional pseudoterminal binding, and how to find out whether it works. */
+import type { SpawnPty } from '@ahpd/sdk';
+/**
+ * The binding, if this machine has one that runs.
+ *
+ * With it, shells run under a real terminal and the shell's own OSC 133 marks
+ * turn into command boundaries. Without it they run on pipes and the state
+ * says `isPty: false`, which is what the protocol has that flag for.
+ */
+export declare const pty: () => Promise<{
+    pty?: SpawnPty;
+}>;

package/dist/pty.js

@@ -0,0 +1,56 @@
+/** The optional pseudoterminal binding, and how to find out whether it works. */
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+/**
+ * By name at runtime, so the type checker is not asked for a module that may
+ * not be installed - which is the whole point of it being optional.
+ */
+const MODULE = 'node-pty';
+/** This file, as the child is told to run it. */
+const SELF = fileURLToPath(import.meta.url);
+/**
+ * Whether this runtime can load it, asked of a process that is allowed to die.
+ *
+ * `node-pty` is native code, and native code that does not match its runtime
+ * does not throw: `dlopen` aborts the process, or the module panics on a
+ * function the runtime does not implement, and neither is something a
+ * `try/catch` around the import can hold. Bun's install of `node-pty` does
+ * exactly this, which takes the whole daemon down over a feature that is
+ * marked optional.
+ *
+ * So the import is tried in a child of the same runtime first, and only
+ * repeated here once the child has survived it. A crash is then an exit code.
+ */
+const loadable = () => {
+    const probe = spawnSync(process.execPath, [SELF, '--probe'], { stdio: 'ignore' });
+    return probe.status === 0;
+};
+/**
+ * The binding, if this machine has one that runs.
+ *
+ * With it, shells run under a real terminal and the shell's own OSC 133 marks
+ * turn into command boundaries. Without it they run on pipes and the state
+ * says `isPty: false`, which is what the protocol has that flag for.
+ */
+export const pty = async () => {
+    if (!loadable())
+        return {};
+    try {
+        const found = await import(/* @vite-ignore */ MODULE);
+        return typeof found.spawn === 'function' ? { pty: found.spawn } : {};
+    }
+    catch {
+        return {};
+    }
+};
+// The child `loadable` spawns. Nothing else in this file has run yet, and
+// nothing else is imported, so what it exits with is about `node-pty` alone.
+if (process.argv[1] === SELF && process.argv[2] === '--probe') {
+    try {
+        const found = await import(/* @vite-ignore */ MODULE);
+        process.exit(typeof found.spawn === 'function' ? 0 : 1);
+    }
+    catch {
+        process.exit(1);
+    }
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@ahpd/server",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "type": "module",
-  "description": "A server library for the Agent Host Protocol. No agent inside, you pass one in",
+  "description": "An Agent Host Protocol server on Node, Bun or Deno. Ships with a Claude backend",
   "keywords": [
     "ahp",
     "agent-host-protocol",
@@ -12,15 +12,14 @@
     "protocol",
     "json-rpc",
     "websocket",
-    "server",
-    "host",
-    "daemon"
+    "cli",
+    "command-line",
+    "daemon",
+    "claude",
+    "claude-code"
   ],
   "author": "Luiz Fernando Softov <lfs@softov.dev>",
   "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
   "homepage": "https://github.com/softov/ahpd#readme",
   "repository": {
     "type": "git",
@@ -30,32 +29,23 @@
   "bugs": {
     "url": "https://github.com/softov/ahpd/issues"
   },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "development": "./src/index.ts",
-      "default": "./dist/index.js"
-    }
+  "bin": {
+    "ahpd": "./dist/main.js"
   },
   "files": [
     "dist",
-    "src",
     "README.md"
   ],
   "engines": {
     "node": ">=22"
   },
-  "optionalDependencies": {
-    "ws": "^8.18.0",
-    "node-pty": "^1.1.0-beta40"
+  "dependencies": {
+    "@microsoft/agent-host-protocol": "^0.9.0",
+    "@ahpd/agent-claude": "^0.3.0",
+    "@ahpd/sdk": "^0.3.0"
   },
-  "peerDependencies": {
-    "@microsoft/agent-host-protocol": "^0.9.0"
-  },
-  "devDependencies": {
-    "@microsoft/agent-host-protocol": "^0.9.0"
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {}
 }

package/dist/automations.d.ts

@@ -1,4 +0,0 @@
-/** Automations held in memory, run when somebody asks. */
-import type { AutomationStore } from './types/automations.js';
-export declare function memoryAutomations(): AutomationStore;
-//# sourceMappingURL=automations.d.ts.map

package/dist/automations.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"automations.d.ts","sourceRoot":"","sources":["../src/automations.ts"],"names":[],"mappings":"AAAA,0DAA0D;AAG1D,OAAO,KAAK,EAA6B,eAAe,EAAgB,MAAM,wBAAwB,CAAC;AAsBvG,wBAAgB,iBAAiB,IAAI,eAAe,CAkLnD"}

package/dist/automations.js

@@ -1,191 +0,0 @@
-/** Automations held in memory, run when somebody asks. */
-import { randomUUID } from 'node:crypto';
-/**
- * The automations of a host that does not schedule.
- *
- * Deliberately half a store, and the half worth having first: definitions can
- * be written, patched, listed and *run*, and nothing here holds a clock. An
- * automation with a schedule trigger is accepted, kept and reported with no
- * `nextRunAt` - which is the honest form of "this host will not fire that",
- * and is what stops a client drawing a next-run time that will never arrive.
- *
- * Everything is in memory, so it goes when the process does. A store that
- * outlives a restart is a different implementation of the same interface, and
- * the reason the interface exists.
- */
-const now = () => new Date().toISOString();
-/** How many runs a summary list carries before it needs a cursor. */
-const PAGE = 20;
-export function memoryAutomations() {
-    const held = new Map();
-    /** Runs by automation, newest first. */
-    const history = new Map();
-    /** Every run by its own URI, for the channel a client watches it on. */
-    const byRun = new Map();
-    const listeners = [];
-    const said = (event) => {
-        for (const listener of listeners)
-            listener(event);
-    };
-    /** The summary form of a run, which is what an automation carries. */
-    const summary = (run) => ({
-        resource: run.resource,
-        automation: run.automation,
-        origin: run.origin,
-        lifecycle: run.lifecycle,
-        sessionCount: run.sessions.length,
-        ...(run.primarySession !== undefined ? { primarySession: run.primarySession } : {}),
-    });
-    /** Rebuild the entry a client reads, so `runs` and `operations` are never stale. */
-    const entry = (automation) => {
-        const enabled = automation.definition.enabled !== false;
-        return {
-            ...automation,
-            runs: (history.get(automation.resource) ?? []).slice(0, PAGE).map(summary),
-            ...((history.get(automation.resource) ?? []).length > PAGE
-                ? { runsNextCursor: String(PAGE) }
-                : {}),
-            // `run` only where it would do something. A disabled automation is one
-            // somebody switched off, and offering the button anyway is a control
-            // that argues with the switch beside it.
-            operations: enabled ? ['update', 'remove', 'run'] : ['update', 'remove'],
-        };
-    };
-    return {
-        list: () => [...held.values()].map(entry),
-        get: (resource) => {
-            const found = held.get(resource);
-            return found && entry(found);
-        },
-        /*
-         * What this store understands, which is nothing.
-         *
-         * This command answers with *event* triggers. Schedule triggers are
-         * protocol-defined and never listed here, and manual is not a trigger at
-         * all - the protocol says an empty trigger list is what manual-only means.
-         * So a store with no event triggers answers with none, and a client reads
-         * "this host will not fire that" from the absent `nextRunAt` instead.
-         */
-        triggers: () => [],
-        create: (resource, definition) => {
-            const at = now();
-            const made = {
-                resource,
-                definition,
-                runs: [],
-                operations: [],
-                createdAt: at,
-                modifiedAt: at,
-            };
-            held.set(resource, made);
-            said({ automation: resource });
-            return entry(made);
-        },
-        update: (resource, changes) => {
-            const found = held.get(resource);
-            if (!found)
-                return undefined;
-            // A patch: absent keys are left alone, which is the whole difference
-            // between this and a write. A client sending the whole definition back
-            // would otherwise revert whatever another client changed meanwhile.
-            const after = {
-                ...found,
-                definition: { ...found.definition, ...changes },
-                modifiedAt: now(),
-            };
-            held.set(resource, after);
-            said({ automation: resource });
-            return entry(after);
-        },
-        remove: (resource) => {
-            if (!held.delete(resource))
-                return false;
-            for (const run of history.get(resource) ?? [])
-                byRun.delete(run.resource);
-            history.delete(resource);
-            said({ removed: resource });
-            return true;
-        },
-        run: async (resource, origin, start) => {
-            const found = held.get(resource);
-            if (!found)
-                return undefined;
-            if (found.definition.enabled === false)
-                return undefined;
-            const template = (typeof found.definition.session === 'object' && found.definition.session !== null
-                ? found.definition.session
-                : {});
-            const message = (typeof found.definition.message === 'object' && found.definition.message !== null
-                ? found.definition.message
-                : {});
-            const run = {
-                resource: `ahp-automation-run:/${randomUUID()}`,
-                automation: resource,
-                origin,
-                lifecycle: { status: 'pending', createdAt: now() },
-                sessions: [],
-            };
-            byRun.set(run.resource, run);
-            const past = history.get(resource) ?? [];
-            // Newest first, which is the order a client shows them in.
-            history.set(resource, [run, ...past]);
-            said({ automation: resource, run: run.resource });
-            const directories = Array.isArray(template.workingDirectories) ? template.workingDirectories : [];
-            const where = typeof directories[0] === 'string'
-                ? directories[0].replace(/^file:\/\//, '')
-                : undefined;
-            const options = {
-                ...(typeof template.provider === 'string' ? { provider: template.provider } : {}),
-                ...(where !== undefined ? { workingDirectory: where } : {}),
-                ...(typeof template.config === 'object' && template.config !== null
-                    ? { config: template.config }
-                    : {}),
-                text: typeof message.text === 'string' ? message.text : String(found.definition.title ?? ''),
-                origin: { kind: 'automation', automation: resource, run: run.resource },
-            };
-            try {
-                const session = await start(options);
-                run.sessions = [session];
-                run.primarySession = session;
-                run.lifecycle = { ...run.lifecycle, status: 'running', startedAt: now() };
-            }
-            catch (error) {
-                // Failed, and why. A run that vanished would be indistinguishable from
-                // one that never started.
-                run.lifecycle = {
-                    ...run.lifecycle,
-                    status: 'failed',
-                    endedAt: now(),
-                    error: { message: error instanceof Error ? error.message : String(error) },
-                };
-            }
-            said({ automation: resource, run: run.resource });
-            return run;
-        },
-        runOf: (resource) => byRun.get(resource),
-        unlink: (resource, session) => {
-            const run = byRun.get(resource);
-            if (run === undefined || !run.sessions.includes(session))
-                return false;
-            run.sessions = run.sessions.filter((one) => one !== session);
-            // The protocol says removing the primary clears it. A run pointing at a
-            // session that is gone is a run a client opens onto nothing.
-            if (run.primarySession === session)
-                delete run.primarySession;
-            said({ automation: run.automation, run: run.resource });
-            return true;
-        },
-        runs: (resource, cursor) => {
-            const all = history.get(resource) ?? [];
-            const from = cursor === undefined ? 0 : Number(cursor);
-            const at = Number.isFinite(from) && from >= 0 ? from : 0;
-            const page = all.slice(at, at + PAGE);
-            return {
-                items: page.map(summary),
-                ...(at + PAGE < all.length ? { nextCursor: String(at + PAGE) } : {}),
-            };
-        },
-        onChanged: (observer) => { listeners.push(observer); },
-    };
-}
-//# sourceMappingURL=automations.js.map