@koalaauto/agentchannel 0.0.0-stage → 3.0.0-rc.1

package/dist/src/runner/state.d.ts

@@ -0,0 +1,68 @@
+export interface RunRecord {
+    taskId: string;
+    runId: string;
+    phase: 'running' | 'parked';
+    workdir: string;
+    runToken: string;
+    tokenAt: number;
+    handoffVersion?: number;
+    /** The agent stopped once without finishing and was asked to finish (runner afterWork). */
+    nudged?: boolean;
+    /** Message ids the worker has already been shown. */
+    seen: string[];
+    /** S1: waiting for the worker owner to approve agent-config changes in links.base. */
+    gate?: {
+        requestId: string;
+        files: string[];
+    };
+    /** Cross-repo: other repos readable for this task (links.repos). */
+    readRepos?: ReadRepo[];
+    /** Attachment URLs the worker has already been shown. */
+    files?: string[];
+}
+/** A read-only repo of a cross-repo task: shown to the agent at `path`; `roots` are made readable. */
+export interface ReadRepo {
+    name: string;
+    path: string;
+    roots: string[];
+}
+export interface RunsFile {
+    runs: Record<string, RunRecord>;
+    /** Question ids we already ran (or permanently skipped) an answer run for, with their task. */
+    handledQuestions: Record<string, {
+        task: string;
+        at: string;
+    } | string>;
+    /** Tasks that already got the one budget decision_request (§14.6). */
+    budgetNotified: Record<string, string>;
+}
+export interface SessionRef {
+    id: string;
+    cwd: string;
+}
+export interface SessionsFile {
+    [taskId: string]: {
+        work?: SessionRef;
+        answer?: SessionRef;
+    };
+}
+/** Persisted runner state: runs.json and sessions.json, both mode 0600. */
+export declare class RunnerState {
+    readonly home: string;
+    readonly runsPath: string;
+    readonly sessionsPath: string;
+    runs: RunsFile;
+    sessions: SessionsFile;
+    constructor(home: string);
+    saveRuns(): void;
+    saveSessions(): void;
+    get(taskId: string): RunRecord | undefined;
+    put(rec: RunRecord): void;
+    drop(taskId: string): void;
+    /** Task ids referenced by bookkeeping entries (handled questions, budget notices). */
+    bookkeepingTasks(): string[];
+    /** C8: forget bookkeeping (and sessions) of tasks that are terminal or gone. */
+    pruneTasks(taskIds: string[]): void;
+    setSession(taskId: string, kind: 'work' | 'answer', ref: SessionRef): void;
+    session(taskId: string, kind: 'work' | 'answer'): SessionRef | undefined;
+}

package/dist/src/runner/state.js

@@ -0,0 +1,80 @@
+import { join } from 'node:path';
+import { readJson, writeJsonPrivate } from '../config.js';
+/** Persisted runner state: runs.json and sessions.json, both mode 0600. */
+export class RunnerState {
+    home;
+    runsPath;
+    sessionsPath;
+    runs;
+    sessions;
+    constructor(home) {
+        this.home = home;
+        this.runsPath = join(home, 'runs.json');
+        this.sessionsPath = join(home, 'sessions.json');
+        const r = readJson(this.runsPath, {});
+        this.runs = { runs: r.runs ?? {}, handledQuestions: r.handledQuestions ?? {}, budgetNotified: r.budgetNotified ?? {} };
+        this.sessions = readJson(this.sessionsPath, {});
+    }
+    saveRuns() {
+        writeJsonPrivate(this.runsPath, this.runs);
+    }
+    saveSessions() {
+        writeJsonPrivate(this.sessionsPath, this.sessions);
+    }
+    get(taskId) {
+        return this.runs.runs[taskId];
+    }
+    put(rec) {
+        this.runs.runs[rec.taskId] = rec;
+        this.saveRuns();
+    }
+    drop(taskId) {
+        if (this.runs.runs[taskId]) {
+            delete this.runs.runs[taskId];
+            this.saveRuns();
+        }
+    }
+    /** Task ids referenced by bookkeeping entries (handled questions, budget notices). */
+    bookkeepingTasks() {
+        const ids = new Set(Object.keys(this.runs.budgetNotified));
+        for (const v of Object.values(this.runs.handledQuestions))
+            if (typeof v === 'object' && v?.task)
+                ids.add(v.task);
+        return [...ids];
+    }
+    /** C8: forget bookkeeping (and sessions) of tasks that are terminal or gone. */
+    pruneTasks(taskIds) {
+        if (!taskIds.length)
+            return;
+        const drop = new Set(taskIds);
+        for (const id of taskIds) {
+            delete this.runs.budgetNotified[id];
+            delete this.runs.runs[id];
+        }
+        for (const [q, v] of Object.entries(this.runs.handledQuestions)) {
+            if (typeof v === 'object' && drop.has(v.task))
+                delete this.runs.handledQuestions[q];
+        }
+        this.saveRuns();
+        let sessions = false;
+        for (const id of taskIds) {
+            if (this.sessions[id]) {
+                delete this.sessions[id];
+                sessions = true;
+            }
+        }
+        if (sessions)
+            this.saveSessions();
+    }
+    setSession(taskId, kind, ref) {
+        const cur = this.sessions[taskId] ?? {};
+        if (cur[kind]?.id === ref.id && cur[kind]?.cwd === ref.cwd)
+            return;
+        cur[kind] = ref;
+        this.sessions[taskId] = cur;
+        this.saveSessions();
+    }
+    session(taskId, kind) {
+        return this.sessions[taskId]?.[kind];
+    }
+}

package/dist/src/runner/workspace.d.ts

@@ -0,0 +1,70 @@
+import type { Task } from '../client.js';
+import type { ReadRepo } from './state.js';
+export declare function isGitRepo(dir: string): Promise<boolean>;
+export declare function branchName(agentName: string, taskId: string): string;
+export interface Workspace {
+    prepare(task: Task, agentName: string): Promise<string>;
+    /** Remove the work dir for a task (the branch is kept). */
+    remove(taskId: string): Promise<void>;
+    /** Task ids that have a work dir. */
+    list(): string[];
+    /** mtime of a task's work dir. */
+    mtime(taskId: string): number;
+    /**
+     * S1: agent-config files (.claude/, .mcp.json, CLAUDE.md, AGENTS.md) that the
+     * task's links.base adds or changes relative to the runner's HEAD.
+     */
+    sensitiveChanges?(task: Task): Promise<string[]>;
+    /**
+     * Cross-repo: the task's links.repos (besides the primary repo), made readable.
+     * Unknown names throw (the task fails with the message).
+     */
+    readRepos?(task: Task): Promise<ReadRepo[]>;
+    /** S10: commit the work dir's changes on the task branch after a run. Returns the commit sha, if any. */
+    commit?(taskId: string, message: string): Promise<string | undefined>;
+}
+/** Paths whose change by a sender-chosen base needs the worker owner's approval (S1). */
+export declare function isSensitivePath(p: string): boolean;
+export declare const REPO_NAME_RE: RegExp;
+/** P3: parse `--repo name=path` values (relative paths resolve against cwd). */
+export declare function parseRepoFlags(values: string[], cwd?: string): Record<string, string>;
+/**
+ * Per-task git worktree (from links.base or HEAD) or a plain per-task dir (§6 / §14.14).
+ * P3: `links.repo` names the repo; `repos` maps names to local paths. A task
+ * without links.repo uses `dir`. An unknown name is an error (the task fails).
+ */
+export declare class GitWorkspace implements Workspace {
+    readonly dir: string;
+    private log;
+    readonly repos: Record<string, string>;
+    readonly root: string;
+    constructor(dir: string, home: string, log?: (s: string) => void, repos?: Record<string, string>);
+    /** The local repo a task works in (P3). */
+    repoDir(task: Task): string;
+    /** Map a repo name to its local path, or fail with the names this runner knows. */
+    lookup(r: unknown, what: string): string;
+    /** Where read-only checkouts of a task's other repos go (next to, not inside, its worktree). */
+    refRoot(taskId: string): string;
+    /**
+     * Cross-repo: links.repos = [{repo, base?}]. The primary repo (links.repo or
+     * --dir) is skipped. With a base, the repo is checked out detached at that
+     * base into <work>/<taskId>.ref/<name> (a git worktree; the agent can read it,
+     * never write it). Without a base, the mapped repo itself is made readable.
+     */
+    readRepos(task: Task): Promise<ReadRepo[]>;
+    path(taskId: string): string;
+    prepare(task: Task, agentName: string): Promise<string>;
+    private resolveRef;
+    /** The main repo a worktree belongs to (any configured repo), from its git common dir. */
+    private ownerRepo;
+    remove(taskId: string): Promise<void>;
+    sensitiveChanges(task: Task): Promise<string[]>;
+    /**
+     * S10: agents cannot write the main repo's .git, so the runner commits for
+     * them. Hooks are disabled (core.hooksPath=/dev/null, --no-verify): the work
+     * dir content is agent-written and must never run outside the sandbox.
+     */
+    commit(taskId: string, message: string): Promise<string | undefined>;
+    list(): string[];
+    mtime(taskId: string): number;
+}

package/dist/src/runner/workspace.js

@@ -0,0 +1,265 @@
+import { execFile } from 'node:child_process';
+import { existsSync, mkdirSync, readdirSync, rmSync, statSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+const pexec = promisify(execFile);
+async function git(cwd, args) {
+    const { stdout } = await pexec('git', args, { cwd, encoding: 'utf8' });
+    return stdout.trim();
+}
+export async function isGitRepo(dir) {
+    try {
+        return (await git(dir, ['rev-parse', '--is-inside-work-tree'])) === 'true';
+    }
+    catch {
+        return false;
+    }
+}
+export function branchName(agentName, taskId) {
+    return `ach/${agentName}/${taskId.slice(0, 8)}`;
+}
+/** Paths whose change by a sender-chosen base needs the worker owner's approval (S1). */
+export function isSensitivePath(p) {
+    return /^\.claude(\/|$)/.test(p) || p === '.mcp.json' || /(^|\/)(CLAUDE|AGENTS)(\.local)?\.md$/i.test(p) || /(^|\/)\.codex(\/|$)/.test(p);
+}
+export const REPO_NAME_RE = /^[A-Za-z0-9._-]{1,64}$/;
+/** P3: parse `--repo name=path` values (relative paths resolve against cwd). */
+export function parseRepoFlags(values, cwd = process.cwd()) {
+    const out = {};
+    for (const v of values) {
+        const i = v.indexOf('=');
+        const name = i > 0 ? v.slice(0, i).trim() : '';
+        const path = i > 0 ? v.slice(i + 1).trim() : '';
+        if (!REPO_NAME_RE.test(name) || !path)
+            throw new Error(`--repo must be name=path (got "${v}")`);
+        out[name] = resolve(cwd, path);
+    }
+    return out;
+}
+/**
+ * Per-task git worktree (from links.base or HEAD) or a plain per-task dir (§6 / §14.14).
+ * P3: `links.repo` names the repo; `repos` maps names to local paths. A task
+ * without links.repo uses `dir`. An unknown name is an error (the task fails).
+ */
+export class GitWorkspace {
+    dir;
+    log;
+    repos;
+    root;
+    constructor(dir, home, log = () => { }, repos = {}) {
+        this.dir = dir;
+        this.log = log;
+        this.repos = repos;
+        this.root = join(home, 'work');
+    }
+    /** The local repo a task works in (P3). */
+    repoDir(task) {
+        const r = task.links?.repo;
+        if (r === undefined || r === null || r === '')
+            return this.dir;
+        return this.lookup(r, 'links.repo');
+    }
+    /** Map a repo name to its local path, or fail with the names this runner knows. */
+    lookup(r, what) {
+        if (typeof r !== 'string' || !REPO_NAME_RE.test(r))
+            throw new Error(`invalid ${what} ${JSON.stringify(r)}`);
+        if (this.repos[r])
+            return this.repos[r];
+        if (basename(this.dir) === r)
+            return this.dir;
+        const known = [...Object.keys(this.repos), basename(this.dir)].join(', ');
+        throw new Error(`unknown repo "${r}": this runner knows ${known || '(none)'}. Restart it with --repo ${r}=<path> (or add it to "repos" in config.json).`);
+    }
+    /** Where read-only checkouts of a task's other repos go (next to, not inside, its worktree). */
+    refRoot(taskId) {
+        return `${this.path(taskId)}.ref`;
+    }
+    /**
+     * Cross-repo: links.repos = [{repo, base?}]. The primary repo (links.repo or
+     * --dir) is skipped. With a base, the repo is checked out detached at that
+     * base into <work>/<taskId>.ref/<name> (a git worktree; the agent can read it,
+     * never write it). Without a base, the mapped repo itself is made readable.
+     */
+    async readRepos(task) {
+        const list = task.links?.repos;
+        if (list === undefined || list === null)
+            return [];
+        if (!Array.isArray(list))
+            throw new Error('links.repos must be a list of {repo, base?}');
+        const primary = this.repoDir(task);
+        const out = [];
+        for (const e of list) {
+            const name = e?.repo;
+            const dir = this.lookup(name, 'links.repos[].repo');
+            if (dir === primary || out.some((x) => x.name === name))
+                continue;
+            const base = e?.base;
+            if (base === undefined || base === null || base === '' || !(await isGitRepo(dir))) {
+                out.push({ name, path: dir, roots: [dir] });
+                continue;
+            }
+            if (typeof base !== 'string' || !/^[A-Za-z0-9._\/-]+$/.test(base) || base.startsWith('-'))
+                throw new Error(`invalid base for repo ${name}: ${JSON.stringify(base)}`);
+            const p = join(this.refRoot(task.id), name);
+            if (!existsSync(p)) {
+                mkdirSync(this.refRoot(task.id), { recursive: true, mode: 0o700 });
+                try {
+                    await git(dir, ['fetch', '--all', '--prune']);
+                }
+                catch (err) {
+                    this.log(`git fetch failed in ${dir}: ${err?.message ?? err}`);
+                }
+                const start = await this.resolveRef(dir, base);
+                await git(dir, ['worktree', 'add', '--detach', p, start]);
+            }
+            const common = await git(p, ['rev-parse', '--path-format=absolute', '--git-common-dir']).catch(() => '');
+            out.push({ name, path: p, roots: [p, ...(common ? [common] : [])] });
+        }
+        return out;
+    }
+    path(taskId) {
+        if (!/^[A-Za-z0-9_-]+$/.test(taskId))
+            throw new Error(`bad task id ${taskId}`);
+        return join(this.root, taskId);
+    }
+    async prepare(task, agentName) {
+        const p = this.path(task.id);
+        const dir = this.repoDir(task);
+        if (existsSync(p))
+            return p;
+        mkdirSync(this.root, { recursive: true, mode: 0o700 });
+        if (!(await isGitRepo(dir))) {
+            mkdirSync(p, { recursive: true, mode: 0o700 });
+            return p;
+        }
+        const branch = branchName(agentName, task.id);
+        const base = typeof task.links?.base === 'string' ? task.links.base : undefined;
+        let start = 'HEAD';
+        if (base) {
+            if (!/^[A-Za-z0-9._\/-]+$/.test(base) || base.startsWith('-'))
+                throw new Error(`invalid links.base "${base}"`);
+            try {
+                await git(dir, ['fetch', '--all', '--prune']);
+            }
+            catch (e) {
+                this.log(`git fetch failed: ${e?.message ?? e}`);
+            }
+            start = await this.resolveRef(dir, base);
+        }
+        let branchExists = false;
+        try {
+            await git(dir, ['rev-parse', '--verify', '--quiet', `refs/heads/${branch}`]);
+            branchExists = true;
+        }
+        catch {
+            /* new branch */
+        }
+        if (branchExists)
+            await git(dir, ['worktree', 'add', p, branch]);
+        else
+            await git(dir, ['worktree', 'add', '-b', branch, p, start]);
+        return p;
+    }
+    async resolveRef(dir, base) {
+        for (const cand of [base, `origin/${base}`]) {
+            try {
+                await git(dir, ['rev-parse', '--verify', '--quiet', `${cand}^{commit}`]);
+                return cand;
+            }
+            catch {
+                /* try next */
+            }
+        }
+        throw new Error(`links.base "${base}" not found in ${dir}`);
+    }
+    /** The main repo a worktree belongs to (any configured repo), from its git common dir. */
+    async ownerRepo(p) {
+        try {
+            const common = await git(p, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+            const abs = isAbsolute(common) ? common : resolve(p, common);
+            return basename(abs) === '.git' ? dirname(abs) : abs;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async remove(taskId) {
+        const p = this.path(taskId);
+        const ref = this.refRoot(taskId);
+        if (existsSync(ref)) {
+            for (const n of readdirSync(ref)) {
+                const rp = join(ref, n);
+                const owner = await this.ownerRepo(rp);
+                if (owner && (await isGitRepo(owner)))
+                    await git(owner, ['worktree', 'remove', '--force', rp]).catch(() => '');
+            }
+            rmSync(ref, { recursive: true, force: true });
+        }
+        if (!existsSync(p))
+            return;
+        const owner = (await this.ownerRepo(p)) ?? this.dir;
+        if (await isGitRepo(owner)) {
+            try {
+                await git(owner, ['worktree', 'remove', '--force', p]);
+                return;
+            }
+            catch {
+                /* not a worktree of this repo; fall through */
+            }
+        }
+        rmSync(p, { recursive: true, force: true });
+        for (const d of new Set([owner, this.dir, ...Object.values(this.repos)])) {
+            if (await isGitRepo(d))
+                await git(d, ['worktree', 'prune']).catch(() => '');
+        }
+    }
+    async sensitiveChanges(task) {
+        const base = typeof task.links?.base === 'string' ? task.links.base : undefined;
+        const dir = this.repoDir(task);
+        if (!base || !(await isGitRepo(dir)))
+            return [];
+        const start = await this.resolveRef(dir, base);
+        const out = await git(dir, ['diff', '--name-only', '--no-renames', `HEAD...${start}`, '--']);
+        return out.split('\n').filter((l) => l && isSensitivePath(l));
+    }
+    /**
+     * S10: agents cannot write the main repo's .git, so the runner commits for
+     * them. Hooks are disabled (core.hooksPath=/dev/null, --no-verify): the work
+     * dir content is agent-written and must never run outside the sandbox.
+     */
+    async commit(taskId, message) {
+        const p = this.path(taskId);
+        if (!existsSync(p) || !(await isGitRepo(p)))
+            return undefined;
+        const status = await git(p, ['status', '--porcelain']);
+        if (!status)
+            return undefined;
+        const ident = [];
+        try {
+            await git(p, ['config', 'user.email']);
+        }
+        catch {
+            ident.push('-c', 'user.name=AgentChannel runner', '-c', 'user.email=runner@agentchannel.invalid');
+        }
+        const safe = ['-c', 'core.hooksPath=/dev/null', ...ident];
+        await git(p, [...safe, 'add', '-A']);
+        await git(p, [...safe, 'commit', '--no-verify', '-q', '-m', message]);
+        return git(p, ['rev-parse', 'HEAD']);
+    }
+    list() {
+        try {
+            return readdirSync(this.root).filter((n) => /^[A-Za-z0-9_-]+$/.test(n));
+        }
+        catch {
+            return [];
+        }
+    }
+    mtime(taskId) {
+        try {
+            return statSync(this.path(taskId)).mtimeMs;
+        }
+        catch {
+            return 0;
+        }
+    }
+}

package/dist/src/service.d.ts

@@ -0,0 +1,29 @@
+/**
+ * P4: `ach run --install-service` writes a macOS launchd agent or a Linux
+ * systemd user unit that starts this runner at login and restarts it. It only
+ * writes the file and prints how to start it; it never loads the unit.
+ */
+export interface ServiceSpec {
+    platform: 'darwin' | 'linux';
+    agentName: string;
+    /** node binary and cli.js of this install. */
+    node: string;
+    cli: string;
+    /** `run` arguments, without --install-service. */
+    args: string[];
+    env: Record<string, string>;
+    /** Where runner output goes. */
+    logFile: string;
+}
+export interface ServiceFile {
+    path: string;
+    content: string;
+    start: string[];
+    stop: string[];
+}
+export declare function serviceLabel(agentName: string): string;
+export declare function launchdPlist(s: ServiceSpec): string;
+export declare function systemdUnit(s: ServiceSpec): string;
+export declare function serviceFile(s: ServiceSpec, dir?: string): ServiceFile;
+/** Write the unit file (mode 0644; it holds no secrets). Never loads it. */
+export declare function writeServiceFile(f: ServiceFile): void;

package/dist/src/service.js

@@ -0,0 +1,101 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+function xml(s) {
+    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+/** systemd quoting: wrap in double quotes, escape backslash, quote, dollar and percent. */
+function sd(s) {
+    if (/^[A-Za-z0-9_./:=@,+-]+$/.test(s))
+        return s;
+    return `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\$/g, '$$$$').replace(/%/g, '%%')}"`;
+}
+export function serviceLabel(agentName) {
+    return `io.agentchannel.runner.${agentName.replace(/[^A-Za-z0-9-]/g, '-')}`;
+}
+export function launchdPlist(s) {
+    const progArgs = [s.node, s.cli, 'run', ...s.args].map((a) => `    <string>${xml(a)}</string>`).join('\n');
+    const env = Object.entries(s.env)
+        .map(([k, v]) => `    <key>${xml(k)}</key>\n    <string>${xml(v)}</string>`)
+        .join('\n');
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${xml(serviceLabel(s.agentName))}</string>
+  <key>ProgramArguments</key>
+  <array>
+${progArgs}
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+${env}
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+  <key>StandardOutPath</key>
+  <string>${xml(s.logFile)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xml(s.logFile)}</string>
+</dict>
+</plist>
+`;
+}
+export function systemdUnit(s) {
+    const exec = [s.node, s.cli, 'run', ...s.args].map(sd).join(' ');
+    const env = Object.entries(s.env)
+        .map(([k, v]) => `Environment=${sd(`${k}=${v}`)}`)
+        .join('\n');
+    return `[Unit]
+Description=AgentChannel runner (agent ${s.agentName})
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${exec}
+${env}
+Restart=on-failure
+RestartSec=10
+# B7: exit 78 = key rotated or agent deactivated; restarting cannot help.
+RestartPreventExitStatus=78
+
+[Install]
+WantedBy=default.target
+`;
+}
+export function serviceFile(s, dir) {
+    if (s.platform === 'darwin') {
+        const label = serviceLabel(s.agentName);
+        const path = join(dir ?? join(homedir(), 'Library', 'LaunchAgents'), `${label}.plist`);
+        return {
+            path,
+            content: launchdPlist(s),
+            start: [`launchctl bootstrap gui/$(id -u) ${path}`],
+            stop: [`launchctl bootout gui/$(id -u)/${label}`],
+        };
+    }
+    const unit = `agentchannel-runner-${s.agentName.replace(/[^A-Za-z0-9-]/g, '-')}.service`;
+    const path = join(dir ?? join(homedir(), '.config', 'systemd', 'user'), unit);
+    return {
+        path,
+        content: systemdUnit(s),
+        start: ['systemctl --user daemon-reload', `systemctl --user enable --now ${unit}`, `loginctl enable-linger "$USER"   # optional: keep it running while logged out`],
+        stop: [`systemctl --user disable --now ${unit}`],
+    };
+}
+/** Write the unit file (mode 0644; it holds no secrets). Never loads it. */
+export function writeServiceFile(f) {
+    const dir = join(f.path, '..');
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(f.path, f.content, { mode: 0o644 });
+}

package/dist/src/version.d.ts

@@ -0,0 +1,3 @@
+export declare const VERSION = "3.0.0-rc.1";
+/** The npm package (scripts/release.mjs keeps it and VERSION in step with package.json). */
+export declare const PKG_NAME = "@koalaauto/agentchannel";

package/dist/src/version.js

@@ -0,0 +1,3 @@
+export const VERSION = '3.0.0-rc.1';
+/** The npm package (scripts/release.mjs keeps it and VERSION in step with package.json). */
+export const PKG_NAME = '@koalaauto/agentchannel';