@koalaauto/agentchannel 3.12.0 → 3.13.1

package/dist/src/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { execFileSync, execSync, spawn } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
-import { chmodSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
 import { basename, delimiter, dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { HELP, parseCli, UsageError } from './args.js';
@@ -1606,6 +1606,10 @@ async function runCommand(p, io) {
     }
     if (v['install-service'])
         return installService(p, io, { agentName: me.name, dir, repos: repoFlags, home });
+    // started by a service written by an early release (node on the npx cache, which no restart ever refreshes): make it `npx -y <spec>`
+    const moved = await moveOldService(io, me.name, home);
+    if (moved)
+        return UPDATE_EXIT_CODE;
     const runtime = str(v.runtime) ?? (me.runtime === 'codex' ? 'codex' : 'claude');
     const { makeAdapter } = await import('./adapters/index.js');
     const adapter = makeAdapter(runtime, { model: str(v.model) });
@@ -1768,6 +1772,9 @@ async function installService(p, io, o) {
     }, env.ACH_SERVICE_DIR || undefined, env);
     writeServiceFile(f);
     const load = !env.ACH_SERVICE_DIR;
+    // an agent that was renamed has an older service under its former name: two runners on one key. They go.
+    const { retireSiblings } = await import('./servicefix.js');
+    const retired = retireSiblings({ platform, dir: env.ACH_SERVICE_DIR || undefined, env, ownPath: f.path, ownHome: o.home, run: load });
     let failed = '';
     if (load) {
         for (const c of f.start) {
@@ -1787,12 +1794,13 @@ async function installService(p, io, o) {
     const linger = platform === 'linux' && load && !failed ? lingers(env) : true;
     const logs = platform === 'linux' ? `journalctl --user -u ${basename(f.path)} -f` : join(o.home, 'logs', 'runner.log');
     if (v.json) {
-        io.out(JSON.stringify({ path: f.path, started: load && !failed, ...(failed ? { error: failed } : {}), start: f.start, stop: f.stop }, null, 2));
+        io.out(JSON.stringify({ path: f.path, started: load && !failed, ...(failed ? { error: failed } : {}), start: f.start, stop: f.stop, retired }, null, 2));
         return failed ? 1 : 0;
     }
     io.out([
         !load ? `wrote ${f.path} (not loaded: ACH_SERVICE_DIR is set). Start it with:` : failed ? `wrote ${f.path}, but starting it failed: ${failed}\nStart it with:` : `installed and started ${f.path} (also starts at login)`,
         ...(!load || failed ? f.start.map((x) => `  ${x}`) : []),
+        ...retired.map((r) => `stopped and removed the older service of this agent (${r.agentName}): ${r.path}`),
         `Stop it with: ${f.stop.join(' && ')}`,
         `Runner output: ${logs}`,
         ...(linger ? [] : ['Note: it stops when you log out of this machine. To keep it running: sudo loginctl enable-linger "$USER"']),
@@ -1809,6 +1817,38 @@ function lingers(env) {
         return true;
     }
 }
+/** The runner is the service's own process and the service is in the old form: rewrite it, have the supervisor reload it, and stop (the reload starts the new one). */
+async function moveOldService(io, agentName, home) {
+    const env = io.env;
+    const platform = (env.ACH_SERVICE_PLATFORM || process.platform);
+    if (platform !== 'darwin' && platform !== 'linux')
+        return false;
+    const { migrateOldService, reloadDetached, startedByService } = await import('./servicefix.js');
+    if (!env.ACH_SERVICE_DIR && !startedByService(agentName, platform, env))
+        return false;
+    const { npmSpec, whichAll, isBundledBin } = await import('./invite.js');
+    // the new service must be able to start: without an npx to point at, the old one (stale, but running) stays as it is
+    const beside = join(dirname(process.execPath), 'npx');
+    const npx = whichAll('npx', env).find((x) => !isBundledBin(x)) ?? (existsSync(beside) ? beside : '');
+    if (!npx) {
+        io.err('[ach run] this service starts a fixed copy of the CLI from the npx cache, but there is no npx to start it with: leaving it. Run `ach run --install-service` after installing npm.');
+        return false;
+    }
+    let m;
+    try {
+        m = migrateOldService({ agentName, platform, dir: env.ACH_SERVICE_DIR || undefined, env, home, npx, spec: npmSpec() });
+    }
+    catch (e) {
+        io.err(`[ach run] could not rewrite the service file: ${e?.message ?? e}`);
+        return false;
+    }
+    if (!m)
+        return false;
+    io.err(`[ach run] this service started a fixed copy of the CLI from the npx cache, which no restart updates: rewrote ${m.path} to start \`npx -y ${npmSpec()}\` and reloading it`);
+    if (!env.ACH_SERVICE_DIR)
+        reloadDetached(m.start, env);
+    return true;
+}
 function isEntry() {
     try {
         return !!process.argv[1] && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));

package/dist/src/sandboxcheck.js

@@ -219,11 +219,11 @@ export function sandboxFix(st, host) {
             }
             if (appArmor)
                 commands.push(BWRAP_APPARMOR);
-            const what = [need.length ? `install ${need.join(' and ')}` : '', appArmor ? 'let /usr/bin/bwrap create user namespaces under AppArmor (this program only)' : ''].filter(Boolean);
-            const zhWhat = [need.length ? `安装 ${need.join(' 和 ')}` : '', appArmor ? '在 AppArmor 里只放行 /usr/bin/bwrap 创建用户命名空间' : ''].filter(Boolean);
+            const en = [need.length ? `needs ${need.join(' and ')}` : '', appArmor ? 'AppArmor blocks bwrap' : ''].filter(Boolean).join(', ');
+            const zh = [need.length ? `缺 ${need.join('、')}` : '', appArmor ? 'AppArmor 拦了沙箱' : ''].filter(Boolean).join('，');
             return {
-                en: `${name}'s sandbox cannot start on this machine${st.missing?.length ? ` (${st.missing.join(', ')} missing)` : ''}. Fix: ${what.join(', then ')}.`,
-                zh: `${name} 的沙箱在这台机器上起不来${st.missing?.length ? `（缺 ${st.missing.join('、')}）` : ''}。修复：${zhWhat.join('，然后')}。`,
+                en: `${name}'s sandbox cannot start: ${en}.`,
+                zh: `${name} 的沙箱起不来：${zh}。`,
                 commands,
             };
         }

package/dist/src/service.d.ts

@@ -32,3 +32,23 @@ export declare function windowsScript(s: ServiceSpec): string;
 export declare function serviceFile(s: ServiceSpec, dir?: string, env?: NodeJS.ProcessEnv): ServiceFile;
 /** Write the unit file (mode 0644; it holds no secrets). */
 export declare function writeServiceFile(f: ServiceFile): void;
+export interface FoundService {
+    path: string;
+    /** From the file name: what serviceLabel / the unit name made of the agent's name. */
+    agentName: string;
+    command: string[];
+    args: string[];
+    env: Record<string, string>;
+    logFile: string;
+    /** `npx`: starts `npx -y <spec>`, so a restart gets the newest release. `node-cache`: starts node on a file inside the npx cache, which only ever
+     *  runs the release that was cached. `node`: node on some other install. */
+    format: 'npx' | 'node-cache' | 'node' | 'unknown';
+}
+/** Where this platform keeps the files serviceFile() writes. */
+export declare function serviceDir(platform: ServiceSpec['platform'], env?: NodeJS.ProcessEnv): string;
+/** Read a service file this module wrote (launchd plist or systemd unit); null for anything else, a Windows script included. */
+export declare function parseServiceFile(path: string, platform: ServiceSpec['platform'], text: string): FoundService | null;
+/** Every runner service of this user on this machine (launchd and systemd). */
+export declare function listServices(platform: ServiceSpec['platform'], dir?: string, env?: NodeJS.ProcessEnv): FoundService[];
+/** The ServiceSpec that would write this service again (so it can be rewritten with another command). */
+export declare function specOf(s: FoundService, platform: ServiceSpec['platform'], command?: string[]): ServiceSpec;

package/dist/src/service.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 function xml(s) {
@@ -140,3 +140,99 @@ export function writeServiceFile(f) {
         mkdirSync(dir, { recursive: true });
     writeFileSync(f.path, f.content, { mode: 0o644 });
 }
+/** Where this platform keeps the files serviceFile() writes. */
+export function serviceDir(platform, env = process.env) {
+    if (platform === 'win32')
+        return join(env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup');
+    if (platform === 'darwin')
+        return join(homedir(), 'Library', 'LaunchAgents');
+    return join(homedir(), '.config', 'systemd', 'user');
+}
+const unxml = (s) => s.replace(/&quot;/g, '"').replace(/&gt;/g, '>').replace(/&lt;/g, '<').replace(/&amp;/g, '&');
+/** The inverse of sd(): words of an ExecStart line, quoted or not. */
+function sdWords(line) {
+    const out = [];
+    const re = /"((?:[^"\\]|\\.)*)"|(\S+)/g;
+    let m;
+    while ((m = re.exec(line)))
+        out.push(m[1] !== undefined ? m[1].replace(/\\(.)/g, '$1').replace(/\$\$/g, '$').replace(/%%/g, '%') : m[2]);
+    return out;
+}
+const formatOf = (command) => {
+    if (!command.length)
+        return 'unknown';
+    if (/(^|[\\/])npx(\.cmd)?$/.test(command[0]))
+        return 'npx';
+    return command.slice(1).some((x) => /[\\/]_npx[\\/]/.test(x)) ? 'node-cache' : 'node';
+};
+/** Read a service file this module wrote (launchd plist or systemd unit); null for anything else, a Windows script included. */
+export function parseServiceFile(path, platform, text) {
+    let words = [];
+    const env = {};
+    let logFile = '';
+    let agentName = '';
+    if (platform === 'darwin') {
+        const label = /<key>Label<\/key>\s*<string>([^<]*)<\/string>/.exec(text)?.[1];
+        if (!label?.startsWith('io.agentchannel.runner.'))
+            return null;
+        agentName = unxml(label).slice('io.agentchannel.runner.'.length);
+        const arr = /<key>ProgramArguments<\/key>\s*<array>([\s\S]*?)<\/array>/.exec(text)?.[1] ?? '';
+        words = [...arr.matchAll(/<string>([^<]*)<\/string>/g)].map((m) => unxml(m[1]));
+        const dict = /<key>EnvironmentVariables<\/key>\s*<dict>([\s\S]*?)<\/dict>/.exec(text)?.[1] ?? '';
+        for (const m of dict.matchAll(/<key>([^<]*)<\/key>\s*<string>([^<]*)<\/string>/g))
+            env[unxml(m[1])] = unxml(m[2]);
+        logFile = unxml(/<key>StandardOutPath<\/key>\s*<string>([^<]*)<\/string>/.exec(text)?.[1] ?? '');
+    }
+    else if (platform === 'linux') {
+        const exec = /^ExecStart=(.*)$/m.exec(text)?.[1];
+        const base = path.split(/[\\/]/).pop() ?? '';
+        if (!exec || !/^agentchannel-runner-.+\.service$/.test(base))
+            return null;
+        agentName = base.slice('agentchannel-runner-'.length, -'.service'.length);
+        words = sdWords(exec);
+        for (const m of text.matchAll(/^Environment=(.*)$/gm)) {
+            const kv = sdWords(m[1])[0] ?? '';
+            const i = kv.indexOf('=');
+            if (i > 0)
+                env[kv.slice(0, i)] = kv.slice(i + 1);
+        }
+    }
+    else
+        return null;
+    const run = words.indexOf('run');
+    if (run < 1)
+        return null;
+    const command = words.slice(0, run);
+    return { path, agentName, command, args: words.slice(run + 1), env, logFile, format: formatOf(command) };
+}
+/** Every runner service of this user on this machine (launchd and systemd). */
+export function listServices(platform, dir, env = process.env) {
+    if (platform === 'win32')
+        return [];
+    const d = dir ?? serviceDir(platform, env);
+    let names = [];
+    try {
+        names = readdirSync(d);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const f of names) {
+        if (!(platform === 'darwin' ? /^io\.agentchannel\.runner\..+\.plist$/ : /^agentchannel-runner-.+\.service$/).test(f))
+            continue;
+        try {
+            const s = parseServiceFile(join(d, f), platform, readFileSync(join(d, f), 'utf8'));
+            if (s)
+                out.push(s);
+        }
+        catch {
+            /* unreadable: not ours to judge */
+        }
+    }
+    return out;
+}
+/** The ServiceSpec that would write this service again (so it can be rewritten with another command). */
+export function specOf(s, platform, command = s.command) {
+    return { platform, agentName: s.agentName, command, args: s.args, env: s.env, logFile: s.logFile };
+}

package/dist/src/servicefix.d.ts

@@ -0,0 +1,41 @@
+import { type FoundService, type ServiceSpec } from './service.js';
+/** The config dir this service's runner uses: its own AGENTCHANNEL_HOME, else the default one. It names the agent (one key per home). */
+export declare function homeOfService(s: FoundService, env?: NodeJS.ProcessEnv): string;
+export interface Retired {
+    agentName: string;
+    path: string;
+}
+/**
+ * Stop and delete the other services of the agent whose home this is (not the one at `ownPath`). `run` false only deletes the files
+ * (the installer was told not to load anything). Returns what was retired.
+ */
+export declare function retireSiblings(o: {
+    platform: ServiceSpec['platform'];
+    dir?: string;
+    env: NodeJS.ProcessEnv;
+    ownPath: string;
+    ownHome: string;
+    run: boolean;
+}): Retired[];
+/** Was this process started by its own service (launchd, systemd)? A runner someone started by hand must not be replaced by a restart. */
+export declare function startedByService(agentName: string, platform: string, env: NodeJS.ProcessEnv): boolean;
+export interface Migration {
+    path: string;
+    /** Shell commands that make the supervisor load the rewritten file. */
+    start: string[];
+}
+/**
+ * This agent's own service, when it is in the old form (node on the npx cache): rewritten to start `npx -y <spec>`. Null when there is
+ * none, or it is already fine. Writing only; the caller decides when to reload (that ends this very process).
+ */
+export declare function migrateOldService(o: {
+    agentName: string;
+    platform: ServiceSpec['platform'];
+    dir?: string;
+    env: NodeJS.ProcessEnv;
+    home: string;
+    npx: string;
+    spec: string;
+}): Migration | null;
+/** Run the reload so that it outlives this process (the reload stops it): a detached shell. */
+export declare function reloadDetached(start: string[], env: NodeJS.ProcessEnv): void;

package/dist/src/servicefix.js

@@ -0,0 +1,69 @@
+// Keeping an agent's runner service right (issue #4): one service per agent, and a service that starts `npx -y <spec>`.
+//  - Installing a service retires the others on this machine that run the same agent (same AGENTCHANNEL_HOME): a renamed agent
+//    gets a new service label, and the old one went on running beside it.
+//  - A service written by an early release starts node on a file inside the npx cache. A restart (including the self-update's)
+//    runs that same cached file, so the runner never moves to a newer release. At start the runner rewrites such a service to
+//    `npx -y <spec>` and has the supervisor reload it.
+import { execFileSync, spawn } from 'node:child_process';
+import { unlinkSync } from 'node:fs';
+import { achHome } from './config.js';
+import { listServices, serviceFile, serviceLabel, specOf, writeServiceFile } from './service.js';
+/** The config dir this service's runner uses: its own AGENTCHANNEL_HOME, else the default one. It names the agent (one key per home). */
+export function homeOfService(s, env = process.env) {
+    return s.env.AGENTCHANNEL_HOME || achHome({ ...env, AGENTCHANNEL_HOME: '' });
+}
+/**
+ * Stop and delete the other services of the agent whose home this is (not the one at `ownPath`). `run` false only deletes the files
+ * (the installer was told not to load anything). Returns what was retired.
+ */
+export function retireSiblings(o) {
+    const out = [];
+    for (const s of listServices(o.platform, o.dir, o.env)) {
+        if (s.path === o.ownPath || homeOfService(s, o.env) !== o.ownHome)
+            continue;
+        if (o.run) {
+            for (const c of serviceFile(specOf(s, o.platform), o.dir, o.env).stop) {
+                try {
+                    execFileSync('/bin/sh', ['-c', c], { env: o.env, stdio: 'ignore' });
+                }
+                catch {
+                    /* it was not loaded: the file still goes */
+                }
+            }
+        }
+        try {
+            unlinkSync(s.path);
+            out.push({ agentName: s.agentName, path: s.path });
+        }
+        catch {
+            /* cannot delete: left for the person */
+        }
+    }
+    return out;
+}
+/** Was this process started by its own service (launchd, systemd)? A runner someone started by hand must not be replaced by a restart. */
+export function startedByService(agentName, platform, env) {
+    if (platform === 'darwin')
+        return env.XPC_SERVICE_NAME === serviceLabel(agentName);
+    if (platform === 'linux')
+        return !!env.INVOCATION_ID;
+    return false;
+}
+/**
+ * This agent's own service, when it is in the old form (node on the npx cache): rewritten to start `npx -y <spec>`. Null when there is
+ * none, or it is already fine. Writing only; the caller decides when to reload (that ends this very process).
+ */
+export function migrateOldService(o) {
+    const name = o.agentName.replace(/[^A-Za-z0-9-]/g, '-');
+    const own = listServices(o.platform, o.dir, o.env).find((s) => s.agentName === name && homeOfService(s, o.env) === o.home);
+    if (!own || own.format !== 'node-cache')
+        return null;
+    const f = serviceFile(specOf(own, o.platform, [o.npx, '-y', o.spec]), o.dir, o.env);
+    writeServiceFile(f);
+    return { path: f.path, start: f.start };
+}
+/** Run the reload so that it outlives this process (the reload stops it): a detached shell. */
+export function reloadDetached(start, env) {
+    const child = spawn('/bin/sh', ['-c', `sleep 2; ${start.join(' && ')}`], { env, detached: true, stdio: 'ignore' });
+    child.unref();
+}

package/dist/src/version.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "3.12.0";
+export declare const VERSION = "3.13.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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koalaauto/agentchannel",
-  "version": "3.12.0",
+  "version": "3.13.1",
   "description": "Hand work between your team's agents (Claude Code, Codex) and follow it in one panel: the ach CLI, MCP server and runner for AgentChannel v2",
   "keywords": [
     "agentchannel",