@rynx-ai/daemon 0.1.11-beta.4 → 0.1.11-beta.41

package/dist/session-timeline-projection-store.d.ts

@@ -0,0 +1,24 @@
+export interface SessionTimelineProjection {
+    pluginId: string;
+    sessionId: string;
+    projectionId: string;
+    responseId: string;
+    itemId: string;
+    text: string;
+    state: "pending" | "completed";
+    disposition: "created" | "replayed";
+}
+/** Durable identity for a narrow text projection. The text itself deliberately
+ * stays in the canonical Session item; this row only fences retries. */
+export declare function claimSessionTimelineProjection(input: {
+    pluginId: string;
+    sessionId: string;
+    projectionId: string;
+    responseId?: string;
+    text: string;
+}): SessionTimelineProjection;
+export declare function completeSessionTimelineProjection(input: {
+    pluginId: string;
+    sessionId: string;
+    projectionId: string;
+}): void;

package/dist/session-timeline-projection-store.js

@@ -0,0 +1,53 @@
+import { createHash, randomUUID } from "node:crypto";
+import { db } from "./db.js";
+import { transaction } from "./sqlite.js";
+/** Durable identity for a narrow text projection. The text itself deliberately
+ * stays in the canonical Session item; this row only fences retries. */
+export function claimSessionTimelineProjection(input) {
+    const connection = db();
+    const requestHash = createHash("sha256")
+        .update(JSON.stringify({ responseId: input.responseId ?? null, text: input.text }), "utf8")
+        .digest("hex");
+    return transaction(connection, () => {
+        const existing = connection.prepare(`SELECT plugin_id, session_id, projection_id, request_hash, response_id, item_id, state
+         FROM session_timeline_projections
+        WHERE plugin_id = ? AND session_id = ? AND projection_id = ?`).get(input.pluginId, input.sessionId, input.projectionId);
+        if (existing) {
+            if (existing.request_hash !== requestHash) {
+                throw new Error("projection id was reused with different text");
+            }
+            return present(existing, input.text, "replayed");
+        }
+        const responseId = input.responseId?.trim() || `projection_response_${input.projectionId}`;
+        const itemId = `msg_projection_${randomUUID()}`;
+        connection.prepare(`INSERT INTO session_timeline_projections
+         (plugin_id, session_id, projection_id, request_hash, response_id, item_id, state, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, 'pending', ?)`).run(input.pluginId, input.sessionId, input.projectionId, requestHash, responseId, itemId, new Date().toISOString());
+        return {
+            pluginId: input.pluginId,
+            sessionId: input.sessionId,
+            projectionId: input.projectionId,
+            responseId,
+            itemId,
+            text: input.text,
+            state: "pending",
+            disposition: "created",
+        };
+    })();
+}
+export function completeSessionTimelineProjection(input) {
+    db().prepare(`UPDATE session_timeline_projections SET state = 'completed'
+      WHERE plugin_id = ? AND session_id = ? AND projection_id = ?`).run(input.pluginId, input.sessionId, input.projectionId);
+}
+function present(row, text, disposition) {
+    return {
+        pluginId: row.plugin_id,
+        sessionId: row.session_id,
+        projectionId: row.projection_id,
+        responseId: row.response_id,
+        itemId: row.item_id,
+        text,
+        state: row.state,
+        disposition,
+    };
+}

package/dist/setup-service.d.ts

@@ -1,3 +1,4 @@
+export { inspectSystemDependencies, type SystemDependencySnapshot, } from "./system-dependencies.js";
 export interface DaemonDiagnosticSnapshot {
     databasePath: string;
     databaseExists: boolean;

package/dist/setup-service.js

@@ -4,6 +4,7 @@ import { createChromeForTestingArtifactStore, isChromeForTestingHostSupported }
 import { ensureBundledOfficialPlugins } from "./bundled-plugins.js";
 import { dbPath } from "./db.js";
 import { listPlugins } from "./plugin-store.js";
+export { inspectSystemDependencies, } from "./system-dependencies.js";
 export async function prepareBundledPlugins() {
     return ensureBundledOfficialPlugins();
 }

package/dist/skills-catalog.d.ts

@@ -1,11 +1,20 @@
-import { type SkillInstallRecipe, type SkillMeta } from "@rynx-ai/core";
-import type { SkillDetail } from "@rynx-ai/protocol/control";
+import { type LocalSkillRuntime, type SkillInstallRecipe, type SkillMeta } from "@rynx-ai/core";
+import type { ControlLocalSkillCandidate, ControlLocalSkillImportResult, SkillDetail } from "@rynx-ai/protocol/control";
 export declare function listCatalogSkills(): Promise<SkillMeta[]>;
 /** Install a skill (or a repo's skills) into the catalog per a full install
  *  recipe; delegates to the core catalog layer (which also writes each skill's
  *  `.rynx-skill.json` install-info file — a catalog-only artifact). Returns
  *  the refreshed catalog. */
 export declare function installCatalogSkill(recipe: SkillInstallRecipe): Promise<SkillMeta[]>;
+export declare function scanLocalCatalogSkillCandidates(runtime: LocalSkillRuntime): Promise<ControlLocalSkillCandidate[]>;
+/**
+ * Register complete local runtime Skill bundles into the owner catalog. Every
+ * content hash gets a durable immutable artifact; the mutable catalog entry's
+ * receipt points at that artifact so old Agent specs keep their exact bytes
+ * after a later catalog update.
+ */
+export declare function importLocalCatalogSkills(runtime: LocalSkillRuntime, keys: string[]): Promise<ControlLocalSkillImportResult[]>;
+export declare function importCatalogSkillsFromArchive(filename: string, contentBase64: string): Promise<ControlLocalSkillImportResult[]>;
 /** Detail for one catalog skill: its metadata + the file tree under its dir. */
 export declare function getCatalogSkill(name: string): Promise<SkillDetail | null>;
 /** Read one text file inside a catalog skill. Path-confined to the skill dir,

package/dist/skills-catalog.js

@@ -4,13 +4,19 @@
  * env-build share one implementation; this module is the daemon-facing wrapper
  * plus the read-only detail/file helpers the Skills page uses.
  */
-import { readdir, readFile, rm, stat } from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
+import { cp, lstat, mkdir, mkdtemp, readdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import path from "node:path";
-import { extractSkillFrontmatter, installIntoCatalog, rynxSkillsDir, scanSkillsDir, readSkillMeta, } from "@rynx-ai/core";
-/** Catalog skill ids are kebab-case (matches the SKILL.md `name` convention). */
-const SKILL_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
+import extractZipArchive from "@electron-internal/extract-zip";
+import { extractSkillFrontmatter, assertSkillPathComponent, installIntoCatalog, collectLocalSkillBundlesInWorker, collectSkillBundlesFromDirectory, scanLocalSkillCandidatesInWorker, rynxSkillsDir, rynxSkillArtifactDir, rynxSkillArtifactsDir, scanSkillsDir, readSkillMeta, writeSkillInstallInfo, } from "@rynx-ai/core";
 /** A single file's contents are capped to keep responses small. */
 const MAX_SKILL_FILE_BYTES = 256 * 1024;
+const MAX_ARCHIVE_ENTRIES = 1_000;
+const MAX_ARCHIVE_EXTRACTED_BYTES = 24 * 1024 * 1024;
+/** Concurrent Control API requests for the same Skill are serialized so the
+ * catalog's backup/swap transaction cannot interleave. */
+const localRegistrationTails = new Map();
 export function listCatalogSkills() {
     return listMergedSkills();
 }
@@ -22,10 +28,101 @@ export async function installCatalogSkill(recipe) {
     await installIntoCatalog(recipe, rynxSkillsDir());
     return listMergedSkills();
 }
+export function scanLocalCatalogSkillCandidates(runtime) {
+    return scanLocalSkillCandidatesInWorker(runtime);
+}
+/**
+ * Register complete local runtime Skill bundles into the owner catalog. Every
+ * content hash gets a durable immutable artifact; the mutable catalog entry's
+ * receipt points at that artifact so old Agent specs keep their exact bytes
+ * after a later catalog update.
+ */
+export async function importLocalCatalogSkills(runtime, keys) {
+    const collected = await collectLocalSkillBundlesInWorker(runtime, keys);
+    return registerCollectedBundles(collected);
+}
+export async function importCatalogSkillsFromArchive(filename, contentBase64) {
+    if (!filename.toLowerCase().endsWith(".zip"))
+        throw new Error("archive must be a .zip file");
+    const content = Buffer.from(contentBase64, "base64");
+    if (content.byteLength === 0)
+        throw new Error("archive is empty");
+    if (content.byteLength > 20 * 1024 * 1024)
+        throw new Error("archive exceeds the 20 MB limit");
+    const staging = await mkdtemp(path.join(tmpdir(), "rynx-skill-archive-"));
+    const archive = path.join(staging, "upload.zip");
+    const extracted = path.join(staging, "extracted");
+    try {
+        await writeFile(archive, content);
+        await mkdir(extracted, { recursive: true });
+        await extractZipArchive(archive, { dir: extracted });
+        await assertExtractedArchiveLimits(extracted);
+        const collected = collectSkillBundlesFromDirectory(extracted);
+        if (collected.bundles.length === 0 && collected.failures.length === 0) {
+            return [{
+                    status: "failed",
+                    name: path.basename(filename, path.extname(filename)),
+                    sourcePath: filename,
+                    message: "No valid Skill bundle was found in the archive.",
+                }];
+        }
+        return registerCollectedBundles({
+            bundles: collected.bundles.map((bundle) => ({ ...bundle, sourcePath: filename })),
+            failures: collected.failures.map((failure) => ({ ...failure, sourcePath: filename })),
+        });
+    }
+    finally {
+        await rm(staging, { recursive: true, force: true });
+    }
+}
+async function assertExtractedArchiveLimits(root) {
+    let entryCount = 0;
+    let extractedBytes = 0;
+    const pending = [root];
+    while (pending.length > 0) {
+        const directory = pending.pop();
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            entryCount += 1;
+            if (entryCount > MAX_ARCHIVE_ENTRIES) {
+                throw new Error(`archive exceeds the ${MAX_ARCHIVE_ENTRIES}-entry limit`);
+            }
+            const absolute = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                pending.push(absolute);
+                continue;
+            }
+            extractedBytes += (await lstat(absolute)).size;
+            if (extractedBytes > MAX_ARCHIVE_EXTRACTED_BYTES) {
+                throw new Error("archive exceeds the 24 MB extracted-size limit");
+            }
+        }
+    }
+}
+async function registerCollectedBundles(collected) {
+    const results = collected.failures.map((failure) => ({
+        status: "failed",
+        name: failure.name,
+        ...(failure.sourcePath ? { sourcePath: failure.sourcePath } : {}),
+        message: failure.message,
+    }));
+    for (const bundle of collected.bundles) {
+        try {
+            results.push(await registerLocalBundle(bundle));
+        }
+        catch (error) {
+            results.push({
+                status: "failed",
+                name: bundle.name,
+                sourcePath: bundle.sourcePath,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return results;
+}
 /** Detail for one catalog skill: its metadata + the file tree under its dir. */
 export async function getCatalogSkill(name) {
-    if (!SKILL_NAME_PATTERN.test(name))
-        throw new Error(`invalid skill name: ${name}`);
+    assertSkillPathComponent(name);
     const dir = path.join(rynxSkillsDir(), name);
     const meta = await readSkillMeta(dir);
     if (!meta)
@@ -62,8 +159,7 @@ async function walkSkillFiles(root, dir) {
 /** Read one text file inside a catalog skill. Path-confined to the skill dir,
  *  size-capped, and binary files are rejected. */
 export async function readCatalogSkillFile(name, relPath) {
-    if (!SKILL_NAME_PATTERN.test(name))
-        throw new Error(`invalid skill name: ${name}`);
+    assertSkillPathComponent(name);
     const dir = path.resolve(path.join(rynxSkillsDir(), name));
     const target = path.resolve(dir, relPath);
     if (target !== dir && !target.startsWith(dir + path.sep)) {
@@ -82,10 +178,221 @@ export async function readCatalogSkillFile(name, relPath) {
 async function listMergedSkills() {
     return (await scanSkillsDir(rynxSkillsDir())).sort((a, b) => a.name.localeCompare(b.name));
 }
+async function registerLocalBundle(bundle) {
+    const previous = localRegistrationTails.get(bundle.name) ?? Promise.resolve();
+    const pending = previous.catch(() => undefined).then(() => registerLocalBundleUnlocked(bundle));
+    localRegistrationTails.set(bundle.name, pending);
+    try {
+        return await pending;
+    }
+    finally {
+        if (localRegistrationTails.get(bundle.name) === pending) {
+            localRegistrationTails.delete(bundle.name);
+        }
+    }
+}
+async function registerLocalBundleUnlocked(bundle) {
+    const catalogRoot = rynxSkillsDir();
+    const currentDir = path.join(catalogRoot, bundle.name);
+    const existing = await readSkillMeta(currentDir);
+    if (existing?.ref && !isManagedLocalArtifact(existing.ref.install)) {
+        return {
+            status: "conflict",
+            name: bundle.name,
+            sourcePath: bundle.sourcePath,
+            skill: toSummary(existing),
+            message: "A Skill with this name is registered from another source.",
+        };
+    }
+    if (existing?.ref?.contentHash === bundle.contentHash) {
+        return {
+            status: "skipped",
+            name: bundle.name,
+            sourcePath: bundle.sourcePath,
+            skill: toSummary(existing),
+            message: "Skill is already up to date.",
+        };
+    }
+    if (await pathExists(currentDir) && !existing) {
+        return {
+            status: "conflict",
+            name: bundle.name,
+            sourcePath: bundle.sourcePath,
+            message: "A receipt-less Skill with this name already exists. Remove it before importing.",
+        };
+    }
+    const artifactDir = rynxSkillArtifactDir(bundle.name, bundle.contentHash);
+    await materializeArtifact(bundle, artifactDir);
+    const ref = {
+        name: bundle.name,
+        install: { tool: "skills-cli", source: artifactDir },
+        contentHash: bundle.contentHash,
+    };
+    await mkdir(catalogRoot, { recursive: true });
+    const stagingRoot = await mkdtemp(path.join(catalogRoot, `.import-${bundle.name}-`));
+    const stagedDir = path.join(stagingRoot, bundle.name);
+    const backupDir = path.join(catalogRoot, `.backup-${bundle.name}-${process.pid}-${randomUUID()}`);
+    let backedUp = false;
+    try {
+        await cp(artifactDir, stagedDir, { recursive: true });
+        await writeSkillInstallInfo(stagedDir, ref);
+        if (await pathExists(currentDir)) {
+            await rename(currentDir, backupDir);
+            backedUp = true;
+        }
+        try {
+            await rename(stagedDir, currentDir);
+        }
+        catch (error) {
+            if (backedUp) {
+                await rename(backupDir, currentDir);
+                backedUp = false;
+            }
+            throw error;
+        }
+        if (backedUp) {
+            await rm(backupDir, { recursive: true, force: true });
+            backedUp = false;
+        }
+    }
+    finally {
+        await rm(stagingRoot, { recursive: true, force: true });
+        if (backedUp && !(await pathExists(currentDir))) {
+            await rename(backupDir, currentDir);
+        }
+    }
+    const meta = await readSkillMeta(currentDir);
+    if (!meta)
+        throw new Error("Imported Skill failed catalog validation");
+    return {
+        status: existing ? "updated" : "created",
+        name: meta.name,
+        sourcePath: bundle.sourcePath,
+        skill: toSummary(meta),
+    };
+}
+async function materializeArtifact(bundle, artifactDir) {
+    if (await pathExists(artifactDir)) {
+        if (await artifactMatchesBundle(bundle, artifactDir))
+            return;
+        throw new Error("Immutable Skill artifact already exists but does not match its content hash");
+    }
+    const artifactsRoot = rynxSkillArtifactsDir();
+    await mkdir(artifactsRoot, { recursive: true });
+    const stagingRoot = await mkdtemp(path.join(artifactsRoot, `.artifact-${bundle.name}-`));
+    const stagedDir = path.join(stagingRoot, bundle.name);
+    try {
+        await mkdir(stagedDir, { recursive: true });
+        const aggregate = createHash("sha256");
+        for (const file of [...bundle.files].sort((left, right) => left.path.localeCompare(right.path))) {
+            const relative = normalizeBundlePath(file.path);
+            const content = Buffer.from(file.contentBase64, "base64");
+            if (content.byteLength !== file.sizeBytes)
+                throw new Error(`Skill file size mismatch: ${relative}`);
+            const sha256 = createHash("sha256").update(content).digest("hex");
+            if (sha256 !== file.sha256)
+                throw new Error(`Skill file hash mismatch: ${relative}`);
+            aggregate.update(relative);
+            aggregate.update("\0");
+            aggregate.update(sha256);
+            aggregate.update("\0");
+            aggregate.update(String(content.byteLength));
+            aggregate.update("\0");
+            const target = path.join(stagedDir, ...relative.split("/"));
+            await mkdir(path.dirname(target), { recursive: true });
+            await writeFile(target, content);
+        }
+        if (aggregate.digest("hex") !== bundle.contentHash)
+            throw new Error("Skill bundle hash mismatch");
+        const parent = path.dirname(artifactDir);
+        await mkdir(parent, { recursive: true });
+        try {
+            await rename(stagedDir, artifactDir);
+        }
+        catch (error) {
+            if (await artifactMatchesBundle(bundle, artifactDir))
+                return;
+            throw error;
+        }
+    }
+    finally {
+        await rm(stagingRoot, { recursive: true, force: true });
+    }
+}
+async function artifactMatchesBundle(bundle, artifactDir) {
+    try {
+        const actualFiles = await walkArtifactFiles(artifactDir, artifactDir);
+        const expectedFiles = [...bundle.files].sort((left, right) => left.path.localeCompare(right.path));
+        if (!actualFiles || actualFiles.length !== expectedFiles.length)
+            return false;
+        for (let index = 0; index < expectedFiles.length; index += 1) {
+            const expected = expectedFiles[index];
+            if (actualFiles[index] !== expected.path)
+                return false;
+            const content = await readFile(path.join(artifactDir, ...expected.path.split("/")));
+            if (content.byteLength !== expected.sizeBytes)
+                return false;
+            if (createHash("sha256").update(content).digest("hex") !== expected.sha256)
+                return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function walkArtifactFiles(root, dir) {
+    const files = [];
+    for (const entry of await readdir(dir, { withFileTypes: true })) {
+        if (entry.isSymbolicLink())
+            return null;
+        const absolute = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            const nested = await walkArtifactFiles(root, absolute);
+            if (!nested)
+                return null;
+            files.push(...nested);
+        }
+        else if (entry.isFile()) {
+            files.push(normalizeBundlePath(path.relative(root, absolute)));
+        }
+    }
+    return files.sort((left, right) => left.localeCompare(right));
+}
+function normalizeBundlePath(value) {
+    const parts = value.replace(/\\/g, "/").split("/");
+    if (parts.some((part) => !part || part === "." || part === "..")) {
+        throw new Error(`Invalid Skill file path: ${value}`);
+    }
+    return parts.join("/");
+}
+function isManagedLocalArtifact(recipe) {
+    if (recipe.tool !== "skills-cli" || !path.isAbsolute(recipe.source))
+        return false;
+    const root = path.resolve(rynxSkillArtifactsDir());
+    const source = path.resolve(recipe.source);
+    const relative = path.relative(root, source);
+    return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+function toSummary(meta) {
+    return {
+        name: meta.name,
+        description: meta.description,
+        ...(meta.ref ? { ref: meta.ref } : {}),
+    };
+}
+async function pathExists(value) {
+    try {
+        await stat(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /** Remove a catalog skill by name. Returns false if it wasn't present. */
 export async function removeCatalogSkill(name) {
-    if (!SKILL_NAME_PATTERN.test(name))
-        throw new Error(`invalid skill name: ${name}`);
+    assertSkillPathComponent(name);
     const dir = path.join(rynxSkillsDir(), name);
     try {
         await stat(dir);

package/dist/sqlite.d.ts

@@ -0,0 +1,22 @@
+import { type DatabaseSync, type StatementSync } from "node:sqlite";
+type SQLiteInput = null | number | bigint | string | NodeJS.ArrayBufferView;
+type SQLiteParameter = SQLiteInput | Record<string, SQLiteInput>;
+type SQLiteOutput = null | number | bigint | string | Uint8Array;
+export type SQLiteTransaction<Args extends unknown[], Result> = ((...args: Args) => Result) & {
+    deferred: (...args: Args) => Result;
+    immediate: (...args: Args) => Result;
+    exclusive: (...args: Args) => Result;
+};
+/** Wrap a synchronous operation in a SQLite transaction. Nested calls use savepoints. */
+export declare function transaction<Args extends unknown[], Result>(connection: DatabaseSync, operation: (...args: Args) => Result): SQLiteTransaction<Args, Result>;
+/** Return only the first column from a native statement, matching scalar-query intent. */
+export declare function scalar(statement: StatementSync): {
+    get(...parameters: SQLiteParameter[]): SQLiteOutput | undefined;
+    all(...parameters: SQLiteParameter[]): SQLiteOutput[];
+};
+/** Match a primary SQLite result code, including extended result codes. */
+export declare function hasSqlitePrimaryCode(error: unknown, primaryCode: number): boolean;
+export declare const SQLITE_BUSY = 5;
+export declare const SQLITE_LOCKED = 6;
+export declare const SQLITE_CONSTRAINT = 19;
+export {};

package/dist/sqlite.js

@@ -0,0 +1,57 @@
+let nextSavepointId = 0;
+/** Wrap a synchronous operation in a SQLite transaction. Nested calls use savepoints. */
+export function transaction(connection, operation) {
+    const run = (mode, args) => {
+        if (connection.isTransaction) {
+            const savepoint = `rynx_transaction_${++nextSavepointId}`;
+            connection.exec(`SAVEPOINT ${savepoint}`);
+            try {
+                const result = operation(...args);
+                connection.exec(`RELEASE SAVEPOINT ${savepoint}`);
+                return result;
+            }
+            catch (error) {
+                if (connection.isTransaction) {
+                    connection.exec(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+                    connection.exec(`RELEASE SAVEPOINT ${savepoint}`);
+                }
+                throw error;
+            }
+        }
+        connection.exec(`BEGIN ${mode}`);
+        try {
+            const result = operation(...args);
+            connection.exec("COMMIT");
+            return result;
+        }
+        catch (error) {
+            if (connection.isTransaction)
+                connection.exec("ROLLBACK");
+            throw error;
+        }
+    };
+    const wrapped = ((...args) => run("DEFERRED", args));
+    wrapped.deferred = (...args) => run("DEFERRED", args);
+    wrapped.immediate = (...args) => run("IMMEDIATE", args);
+    wrapped.exclusive = (...args) => run("EXCLUSIVE", args);
+    return wrapped;
+}
+/** Return only the first column from a native statement, matching scalar-query intent. */
+export function scalar(statement) {
+    statement.setReturnArrays(true);
+    const arrayStatement = statement;
+    return {
+        get: (...parameters) => arrayStatement.get(...parameters)?.[0],
+        all: (...parameters) => arrayStatement.all(...parameters).map((row) => row[0]),
+    };
+}
+/** Match a primary SQLite result code, including extended result codes. */
+export function hasSqlitePrimaryCode(error, primaryCode) {
+    if (!error || typeof error !== "object" || !("errcode" in error))
+        return false;
+    const errcode = error.errcode;
+    return typeof errcode === "number" && (errcode & 0xff) === primaryCode;
+}
+export const SQLITE_BUSY = 5;
+export const SQLITE_LOCKED = 6;
+export const SQLITE_CONSTRAINT = 19;

package/dist/stdio-epipe-guard.d.ts

@@ -3,6 +3,6 @@
  * broken pipe (a `pm2 logs` stream detaching, or a pm2 restart) would otherwise
  * surface as an unhandled `'error'` on the stream and crash a daemon that has
  * no uncaughtException trap. Swallow EPIPE on the std streams; re-throw anything
- * else. (Borrowed from botmux's daemon bootstrap.)
+ * else.
  */
 export declare function installStdioEpipeGuard(): void;

package/dist/stdio-epipe-guard.js

@@ -3,7 +3,7 @@
  * broken pipe (a `pm2 logs` stream detaching, or a pm2 restart) would otherwise
  * surface as an unhandled `'error'` on the stream and crash a daemon that has
  * no uncaughtException trap. Swallow EPIPE on the std streams; re-throw anything
- * else. (Borrowed from botmux's daemon bootstrap.)
+ * else.
  */
 export function installStdioEpipeGuard() {
     for (const stream of [process.stdout, process.stderr]) {

package/dist/system-dependencies.d.ts

@@ -0,0 +1,22 @@
+export interface SystemDependencyStatus {
+    installed: boolean;
+    detail?: string;
+}
+export interface SystemDependencySnapshot {
+    tmux: SystemDependencyStatus;
+}
+export interface SystemDependencyCommandResult {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+    errorCode?: string;
+}
+export interface SystemDependencyCommandOptions {
+    timeoutMs: number;
+}
+export type SystemDependencyCommandRunner = (command: string, args: readonly string[], options: SystemDependencyCommandOptions) => Promise<SystemDependencyCommandResult>;
+export interface SystemDependencyOptions {
+    runCommand?: SystemDependencyCommandRunner;
+    tmuxBin: string;
+}
+export declare function inspectSystemDependencies(options: SystemDependencyOptions): Promise<SystemDependencySnapshot>;