@kin-tio/cli 0.6.0

package/dist/src/runtime/daemon-protocol.js

@@ -0,0 +1,202 @@
+import { createHash, randomBytes } from 'node:crypto';
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import * as z from 'zod/v4';
+import { canonicalPath } from '../lib/path-identity.js';
+import { ensurePrivateDirectory } from '../lib/private-directory.js';
+export const CONTROL_MAX_BYTES = 4 * 1024;
+export const CONTROL_TIMEOUT_MS = 2_000;
+const ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/u;
+const positiveInteger = z.number().int().positive();
+const runId = z.string().regex(ID_PATTERN, 'runId is invalid');
+const token = z.string()
+    .regex(/^[A-Za-z0-9_-]{32,128}$/u, 'control token is invalid');
+const phase = z.enum(['starting', 'running', 'backoff', 'stopping', 'failed']);
+const absolutePath = z.string().min(1).max(4_096).refine((value) => path.isAbsolute(value) && !value.includes('\0'), 'path must be absolute').transform((value) => path.normalize(value));
+const daemonRecordSchema = z.strictObject({
+    version: z.literal(1),
+    runId,
+    daemonPid: positiveInteger,
+    configFile: absolutePath,
+    packageRoot: absolutePath,
+    token,
+});
+const controlRequestSchema = z.strictObject({
+    version: z.literal(1),
+    command: z.enum(['ping', 'stop']),
+    token,
+});
+const controlResponseSchema = z.strictObject({
+    ok: z.boolean(),
+    runId,
+    daemonPid: positiveInteger,
+    workerPid: positiveInteger.optional(),
+    phase,
+    message: z.string().min(1).max(2_048).optional(),
+});
+export function parseDaemonRecord(value) {
+    return Object.freeze(daemonRecordSchema.parse(value));
+}
+export function parseControlRequest(value) {
+    return Object.freeze(controlRequestSchema.parse(value));
+}
+export function parseControlResponse(value) {
+    return Object.freeze(controlResponseSchema.parse(value));
+}
+export function daemonRecordPath(home) {
+    return path.join(path.resolve(home), 'data/daemon.json');
+}
+export function controlAddress(home, platform = process.platform, nonce = '') {
+    const identity = canonicalPath(home).replaceAll('/', '\\').toLowerCase();
+    if (nonce && !ID_PATTERN.test(nonce))
+        throw new Error('control address nonce is invalid');
+    const digest = createHash('sha256')
+        .update(`${identity}\0${nonce}`)
+        .digest('hex')
+        .slice(0, 32);
+    const name = `kintio-${digest}`;
+    return platform === 'win32'
+        ? `\\\\.\\pipe\\${name}`
+        : path.join('/tmp', `${name}.sock`);
+}
+function errorCode(error) {
+    if (!error || typeof error !== 'object' || !('code' in error))
+        return '';
+    return String(error.code ?? '');
+}
+function assertPrivateFile(filePath) {
+    const stat = fs.lstatSync(filePath);
+    if (!stat.isFile() || stat.isSymbolicLink()) {
+        throw new Error(`Daemon metadata is not a regular file: ${filePath}`);
+    }
+    if (process.platform !== 'win32') {
+        const uid = process.getuid?.();
+        if ((uid !== undefined && stat.uid !== uid) || (stat.mode & 0o077) !== 0) {
+            throw new Error(`Daemon metadata has unsafe permissions: ${filePath}`);
+        }
+    }
+    if (stat.size > CONTROL_MAX_BYTES) {
+        throw new Error(`Daemon metadata exceeds ${CONTROL_MAX_BYTES} bytes: ${filePath}`);
+    }
+}
+function readJson(filePath, parse) {
+    try {
+        assertPrivateFile(filePath);
+        const source = fs.readFileSync(filePath, 'utf8');
+        if (Buffer.byteLength(source) > CONTROL_MAX_BYTES) {
+            throw new Error(`Daemon metadata exceeds ${CONTROL_MAX_BYTES} bytes: ${filePath}`);
+        }
+        return parse(JSON.parse(source));
+    }
+    catch (error) {
+        if (errorCode(error) === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+function writeJson(filePath, value) {
+    const directory = ensurePrivateDirectory(path.dirname(filePath));
+    const source = `${JSON.stringify(value)}\n`;
+    if (Buffer.byteLength(source) > CONTROL_MAX_BYTES) {
+        throw new Error(`Daemon metadata exceeds ${CONTROL_MAX_BYTES} bytes: ${filePath}`);
+    }
+    const temporary = path.join(directory, `.${path.basename(filePath)}.${process.pid}.${randomBytes(8).toString('hex')}.tmp`);
+    const descriptor = fs.openSync(temporary, 'wx', 0o600);
+    try {
+        fs.writeFileSync(descriptor, source, 'utf8');
+        fs.fsyncSync(descriptor);
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+    try {
+        fs.renameSync(temporary, filePath);
+    }
+    finally {
+        fs.rmSync(temporary, { force: true });
+    }
+}
+export function readDaemonRecord(home) {
+    return readJson(daemonRecordPath(home), parseDaemonRecord);
+}
+export function writeDaemonRecord(home, record) {
+    writeJson(daemonRecordPath(home), parseDaemonRecord(record));
+}
+function parseResponseLine(source) {
+    const newline = source.indexOf(0x0a);
+    if (newline === -1)
+        throw new Error('control response ended without a newline');
+    if (newline !== source.length - 1) {
+        throw new Error('control response contains more than one message');
+    }
+    const line = source.subarray(0, newline).toString('utf8').replace(/\r$/u, '');
+    return parseControlResponse(JSON.parse(line));
+}
+export async function requestControl(home, command, timeoutMs = CONTROL_TIMEOUT_MS) {
+    if (command !== 'ping' && command !== 'stop') {
+        throw new Error('control command is invalid');
+    }
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        throw new Error('control timeout must be a positive number');
+    }
+    const record = readDaemonRecord(home);
+    if (!record)
+        throw new Error('Kintio daemon record does not exist');
+    const source = `${JSON.stringify({
+        version: 1,
+        command,
+        token: record.token,
+    })}\n`;
+    return await new Promise((resolve, reject) => {
+        const socket = net.createConnection(controlAddress(home, process.platform, record.runId));
+        const chunks = [];
+        let size = 0;
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return false;
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            return true;
+        };
+        const fail = (error) => {
+            if (finish())
+                reject(error);
+        };
+        const timer = setTimeout(() => fail(new Error('Kintio control request timed out')), Math.min(timeoutMs, CONTROL_TIMEOUT_MS));
+        timer.unref?.();
+        socket.once('connect', () => socket.write(source));
+        socket.on('data', (chunk) => {
+            size += chunk.length;
+            if (size > CONTROL_MAX_BYTES) {
+                fail(new Error(`control response exceeds ${CONTROL_MAX_BYTES} bytes`));
+                return;
+            }
+            chunks.push(chunk);
+            const complete = Buffer.concat(chunks, size);
+            if (!complete.includes(0x0a))
+                return;
+            try {
+                const response = parseResponseLine(complete);
+                if (response.runId !== record.runId || response.daemonPid !== record.daemonPid) {
+                    throw new Error('control response identity does not match the daemon record');
+                }
+                if (!response.ok) {
+                    throw new Error(response.message || 'Kintio control request was rejected');
+                }
+                if (finish())
+                    resolve(response);
+            }
+            catch (error) {
+                fail(error);
+            }
+        });
+        socket.once('end', () => {
+            if (!settled)
+                fail(new Error('control response ended before one message arrived'));
+        });
+        socket.once('error', fail);
+    });
+}

package/dist/src/runtime/managed-skill.js

@@ -0,0 +1,49 @@
+import { randomBytes } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertTrustedDirectory, ensureContainedDirectory, ensurePrivateDirectory, } from '../lib/private-directory.js';
+import { samePath } from '../lib/path-identity.js';
+const SKILL_PATH = '.agents/skills/wechat-kf-reply-sop/SKILL.md';
+export function installManagedSkill({ packageRoot, workingDirectory, }) {
+    const workspace = path.resolve(workingDirectory);
+    const file = path.join(workspace, SKILL_PATH);
+    const bundled = path.join(packageRoot, 'codex-workspace', SKILL_PATH);
+    if (samePath(file, bundled)) {
+        if (!regularFile(bundled)) {
+            throw new Error(`Bundled managed Skill is missing: ${bundled}`);
+        }
+        return { file, state: 'current' };
+    }
+    assertTrustedDirectory(ensurePrivateDirectory(workspace), 'Agent working directory', false);
+    const directory = ensureContainedDirectory(workspace, path.dirname(file));
+    assertTrustedDirectory(directory, 'Managed Skill directory', true);
+    const existing = regularFile(file);
+    const content = fs.readFileSync(bundled, 'utf8');
+    if (existing && fs.readFileSync(file, 'utf8') === content) {
+        return { file, state: 'current' };
+    }
+    const temporary = path.join(directory, `.${path.basename(file)}.${process.pid}.${randomBytes(8).toString('hex')}.tmp`);
+    fs.writeFileSync(temporary, content, { flag: 'wx', mode: 0o600 });
+    try {
+        fs.renameSync(temporary, file);
+    }
+    finally {
+        fs.rmSync(temporary, { force: true });
+    }
+    return { file, state: existing ? 'updated' : 'created' };
+}
+function regularFile(filePath) {
+    try {
+        const stat = fs.lstatSync(filePath);
+        if (!stat.isFile() || stat.isSymbolicLink()) {
+            throw new Error(`Managed Skill is not a regular file: ${filePath}`);
+        }
+        return stat;
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            return undefined;
+        }
+        throw error;
+    }
+}

package/dist/src/runtime/native-daemon.js

@@ -0,0 +1,325 @@
+import { spawn } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { parseStartTimeout, WORKER_GRACEFUL_TIMEOUT_MS, } from '../config.js';
+import { ensurePrivateDirectory } from '../lib/private-directory.js';
+import { acquireSingleInstanceLock } from './single-instance-lock.js';
+import { controlAddress, CONTROL_MAX_BYTES, CONTROL_TIMEOUT_MS, daemonRecordPath, parseControlRequest, writeDaemonRecord, } from './daemon-protocol.js';
+const MAX_RESTARTS = 10;
+const RESTART_WINDOW_MS = 5 * 60_000;
+const RESTART_DELAYS_MS = [1_000, 2_000, 4_000, 8_000, 16_000, 30_000];
+const LOG_LIMIT_BYTES = 10 * 1024 * 1024;
+const LOG_GENERATIONS = 5;
+function sleep(milliseconds) {
+    return delay(milliseconds, undefined, { ref: false });
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+class RotatingLog {
+    #filePath;
+    #size;
+    constructor(home) {
+        const directory = ensurePrivateDirectory(path.join(home, 'data/logs'));
+        this.#filePath = path.join(directory, 'kintio.log');
+        this.#size = fs.existsSync(this.#filePath) ? fs.statSync(this.#filePath).size : 0;
+    }
+    write(value) {
+        const bytes = Buffer.isBuffer(value) ? value : Buffer.from(value);
+        if (this.#size + bytes.length > LOG_LIMIT_BYTES)
+            this.#rotate();
+        fs.appendFileSync(this.#filePath, bytes, { mode: 0o600 });
+        this.#size += bytes.length;
+    }
+    line(value) {
+        this.write(`[daemon] ${new Date().toISOString()} ${value}\n`);
+    }
+    #rotate() {
+        for (let generation = LOG_GENERATIONS; generation >= 1; generation -= 1) {
+            const target = `${this.#filePath}.${generation}`;
+            const source = generation === 1
+                ? this.#filePath
+                : `${this.#filePath}.${generation - 1}`;
+            fs.rmSync(target, { force: true });
+            if (fs.existsSync(source))
+                fs.renameSync(source, target);
+        }
+        this.#size = 0;
+    }
+}
+function forceKill(worker) {
+    // Tree-killing by a reusable numeric PID can terminate unrelated host processes.
+    // Current Agent children use stdio/IPC and receive EOF when this exact handle exits.
+    if (worker.exitCode === null && worker.signalCode === null)
+        worker.kill('SIGKILL');
+}
+export async function runNativeDaemon({ home, configFile, packageRoot, environment = process.env, }) {
+    const instanceHome = path.resolve(home);
+    const instanceConfig = path.resolve(configFile);
+    const dataDirectory = ensurePrivateDirectory(path.join(instanceHome, 'data'));
+    const log = new RotatingLog(instanceHome);
+    const daemonLock = acquireSingleInstanceLock({
+        filePath: path.join(dataDirectory, 'daemon.lock'),
+    });
+    const runId = randomBytes(24).toString('base64url');
+    const token = randomBytes(32).toString('base64url');
+    const address = controlAddress(instanceHome, process.platform, runId);
+    const instancePackageRoot = path.resolve(packageRoot);
+    let phase = 'starting';
+    let lastError;
+    let worker;
+    let workerExit = Promise.resolve();
+    let stopping;
+    let cleanup;
+    const sockets = new Set();
+    const restartTimes = [];
+    let resolveFinished;
+    const finished = new Promise((resolve) => { resolveFinished = resolve; });
+    const startupTimeoutMs = parseStartTimeout(environment.KINTIO_START_TIMEOUT_MS);
+    const handleSignal = () => { void shutdown(); };
+    const response = (ok, message) => ({
+        ok,
+        runId,
+        daemonPid: process.pid,
+        ...(worker?.pid ? { workerPid: worker.pid } : {}),
+        phase,
+        ...((message || (ok ? lastError : undefined))
+            ? { message: (message || lastError).slice(0, 2_048) }
+            : {}),
+    });
+    async function stopWorker() {
+        const active = worker;
+        if (!active || active.exitCode !== null || active.signalCode !== null)
+            return;
+        try {
+            if (active.connected)
+                active.send('shutdown');
+        }
+        catch {
+            // The exit listener below remains authoritative.
+        }
+        const graceful = await Promise.race([
+            workerExit.then(() => true),
+            sleep(WORKER_GRACEFUL_TIMEOUT_MS).then(() => false),
+        ]);
+        if (!graceful) {
+            log.line(`worker ${active.pid || 'unknown'} exceeded shutdown timeout; forcing exit`);
+            forceKill(active);
+            const forced = await Promise.race([
+                workerExit.then(() => true),
+                sleep(5_000).then(() => false),
+            ]);
+            if (!forced)
+                throw new Error('worker did not exit after forced termination');
+        }
+    }
+    async function shutdown() {
+        if (stopping)
+            return stopping;
+        stopping = (async () => {
+            phase = 'stopping';
+            try {
+                await stopWorker();
+            }
+            catch (error) {
+                lastError = `worker shutdown failed: ${errorMessage(error)}`;
+                phase = 'failed';
+                log.line(lastError);
+                stopping = undefined;
+                return;
+            }
+            await cleanupControl();
+            resolveFinished();
+        })();
+        return stopping;
+    }
+    function startWorker() {
+        if (phase === 'stopping' || phase === 'failed')
+            return;
+        phase = 'starting';
+        const child = spawn(process.execPath, [path.join(instancePackageRoot, 'dist/index.js')], {
+            cwd: instanceHome,
+            env: {
+                ...environment,
+                KINTIO_HOME: instanceHome,
+                KINTIO_CONFIG_FILE: instanceConfig,
+                KINTIO_MANAGED_WORKER: '1',
+                NODE_ENV: 'production',
+            },
+            stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
+            detached: true,
+            windowsHide: true,
+        });
+        worker = child;
+        lastError = undefined;
+        let readinessExpired = false;
+        const readyTimer = setTimeout(() => {
+            if (worker !== child || phase === 'running' || phase === 'stopping')
+                return;
+            readinessExpired = true;
+            log.line(`worker ${child.pid || 'unknown'} did not publish readiness in time`);
+            void (async () => {
+                forceKill(child);
+                const exited = await Promise.race([
+                    workerExit.then(() => true),
+                    sleep(5_000).then(() => false),
+                ]);
+                if (!exited && worker === child) {
+                    phase = 'failed';
+                    lastError = 'worker did not exit after readiness timeout';
+                }
+            })().catch((error) => {
+                if (worker !== child)
+                    return;
+                phase = 'failed';
+                lastError = errorMessage(error);
+            });
+        }, startupTimeoutMs);
+        readyTimer.unref?.();
+        child.stdout?.on('data', (chunk) => log.write(chunk));
+        child.stderr?.on('data', (chunk) => log.write(chunk));
+        child.once('message', (message) => {
+            if (worker === child &&
+                !readinessExpired &&
+                phase !== 'stopping' &&
+                phase !== 'failed' &&
+                child.exitCode === null &&
+                child.signalCode === null &&
+                message && typeof message === 'object' &&
+                'type' in message && message.type === 'ready' &&
+                'pid' in message && message.pid === child.pid) {
+                clearTimeout(readyTimer);
+                phase = 'running';
+                lastError = undefined;
+            }
+        });
+        child.once('error', (error) => log.line(`worker spawn error: ${error.message}`));
+        workerExit = new Promise((resolve) => {
+            child.once('close', (code, signal) => {
+                clearTimeout(readyTimer);
+                resolve();
+                if (worker !== child)
+                    return;
+                worker = undefined;
+                if (phase === 'stopping' || phase === 'failed')
+                    return;
+                const now = Date.now();
+                restartTimes.push(now);
+                while (restartTimes[0] !== undefined && now - restartTimes[0] > RESTART_WINDOW_MS) {
+                    restartTimes.shift();
+                }
+                const detail = `worker exited code=${code} signal=${signal}`;
+                log.line(detail);
+                if (restartTimes.length > MAX_RESTARTS) {
+                    phase = 'failed';
+                    lastError = 'worker restart limit exceeded';
+                    return;
+                }
+                phase = 'backoff';
+                lastError = detail;
+                const restartDelay = RESTART_DELAYS_MS[Math.min(restartTimes.length - 1, RESTART_DELAYS_MS.length - 1)] || RESTART_DELAYS_MS.at(-1);
+                setTimeout(startWorker, restartDelay).unref?.();
+            });
+        });
+    }
+    if (process.platform !== 'win32')
+        fs.rmSync(address, { force: true });
+    const server = net.createServer((socket) => {
+        sockets.add(socket);
+        socket.once('close', () => sockets.delete(socket));
+        socket.setTimeout(CONTROL_TIMEOUT_MS);
+        const chunks = [];
+        let size = 0;
+        let handled = false;
+        const reject = (message) => {
+            if (handled)
+                return;
+            handled = true;
+            socket.end(`${JSON.stringify(response(false, message))}\n`);
+        };
+        socket.on('data', (chunk) => {
+            if (handled)
+                return;
+            size += chunk.length;
+            if (size > CONTROL_MAX_BYTES) {
+                reject('control request exceeds protocol limit');
+                return;
+            }
+            chunks.push(chunk);
+            const source = Buffer.concat(chunks, size);
+            const newline = source.indexOf(0x0a);
+            if (newline < 0)
+                return;
+            try {
+                const request = parseControlRequest(JSON.parse(source.subarray(0, newline).toString('utf8')));
+                if (request.token !== token) {
+                    reject('control authentication failed');
+                    return;
+                }
+                handled = true;
+                const output = `${JSON.stringify(response(true))}\n`;
+                if (request.command === 'stop') {
+                    socket.end(output, () => { void shutdown(); });
+                }
+                else {
+                    socket.end(output);
+                }
+            }
+            catch (error) {
+                reject(errorMessage(error));
+            }
+        });
+        socket.once('timeout', () => reject('control request timed out'));
+        socket.once('error', () => undefined);
+    });
+    function cleanupControl() {
+        cleanup ??= (async () => {
+            if (server.listening) {
+                await new Promise((resolve, reject) => {
+                    server.close((error) => error ? reject(error) : resolve());
+                    for (const socket of sockets)
+                        socket.destroy();
+                });
+            }
+            else {
+                for (const socket of sockets)
+                    socket.destroy();
+            }
+            fs.rmSync(daemonRecordPath(instanceHome), { force: true });
+            if (process.platform !== 'win32')
+                fs.rmSync(address, { force: true });
+            daemonLock.release();
+        })();
+        return cleanup;
+    }
+    try {
+        await new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(address, () => resolve());
+        });
+        if (process.platform !== 'win32')
+            fs.chmodSync(address, 0o600);
+        writeDaemonRecord(instanceHome, {
+            version: 1,
+            runId,
+            daemonPid: process.pid,
+            configFile: instanceConfig,
+            packageRoot: instancePackageRoot,
+            token,
+        });
+        log.line(`daemon started pid=${process.pid}`);
+        startWorker();
+        process.once('SIGINT', handleSignal);
+        process.once('SIGTERM', handleSignal);
+        await finished;
+    }
+    finally {
+        process.off('SIGINT', handleSignal);
+        process.off('SIGTERM', handleSignal);
+        await cleanupControl();
+        log.line('daemon stopped');
+    }
+}