@smart-tinker/kayla 0.1.0

package/dist/core/doctor.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfigPath = resolveConfigPath;
+exports.resolveRuntimeDataDir = resolveRuntimeDataDir;
+exports.readDoctorConfigInfo = readDoctorConfigInfo;
+exports.checkConfig = checkConfig;
+exports.checkDirs = checkDirs;
+exports.checkSqlite = checkSqlite;
+exports.checkClaude = checkClaude;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const yaml_1 = __importDefault(require("yaml"));
+const storage_1 = require("./storage");
+function isRecord(v) {
+    return !!v && typeof v === "object" && !Array.isArray(v);
+}
+function resolveConfigPath(env) {
+    const p = env.KAYLA_CONFIG?.trim();
+    if (p)
+        return p;
+    const home = env.HOME?.trim();
+    if (home)
+        return node_path_1.default.join(home, ".config", "kayla", "config.yaml");
+    return node_path_1.default.join(process.cwd(), "config", "config.yaml");
+}
+function resolveRuntimeDataDir(env) {
+    const dd = env.KAYLA_RUNTIME_DATA_DIR?.trim();
+    if (dd)
+        return dd;
+    const cfgPath = resolveConfigPath(env);
+    const info = readDoctorConfigInfo(cfgPath);
+    const dataDir = info.runtime?.dataDir?.trim();
+    if (dataDir)
+        return dataDir;
+    const home = env.HOME?.trim();
+    if (home)
+        return node_path_1.default.join(home, ".local", "share", "kayla");
+    return ".kayla-data";
+}
+function readDoctorConfigInfo(configPath) {
+    if (!node_fs_1.default.existsSync(configPath))
+        return {};
+    try {
+        const doc = yaml_1.default.parse(node_fs_1.default.readFileSync(configPath, "utf8"));
+        if (!isRecord(doc))
+            return {};
+        const r = isRecord(doc.runtime) ? doc.runtime : undefined;
+        const dataDir = typeof r?.data_dir === "string" ? r.data_dir.trim() : "";
+        const workspacesDir = typeof r?.workspaces_dir === "string" ? r.workspaces_dir.trim() : "";
+        const uploadsDir = typeof r?.uploads_dir === "string" ? r.uploads_dir.trim() : "";
+        const c = isRecord(doc.claude) ? doc.claude : undefined;
+        const binary = typeof c?.binary === "string" ? c.binary.trim() : "";
+        const out = {};
+        if (dataDir || workspacesDir || uploadsDir) {
+            out.runtime = {
+                dataDir: dataDir || undefined,
+                workspacesDir: workspacesDir || undefined,
+                uploadsDir: uploadsDir || undefined
+            };
+        }
+        if (binary)
+            out.claudeBinary = binary;
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+function checkConfig(configPath) {
+    if (!node_fs_1.default.existsSync(configPath)) {
+        return [
+            {
+                id: "config.file",
+                ok: false,
+                summary: `Missing config file: ${configPath}`,
+                details: "Create config and set telegram.token + telegram.admin_user_ids (or telegram.allowlist.user_ids)."
+            }
+        ];
+    }
+    let doc;
+    try {
+        doc = yaml_1.default.parse(node_fs_1.default.readFileSync(configPath, "utf8"));
+    }
+    catch (err) {
+        return [
+            {
+                id: "config.parse",
+                ok: false,
+                summary: `Failed to parse config: ${configPath}`,
+                details: err instanceof Error ? err.message : String(err)
+            }
+        ];
+    }
+    if (!isRecord(doc)) {
+        return [{ id: "config.schema", ok: false, summary: "Invalid config: expected YAML object" }];
+    }
+    const t = isRecord(doc.telegram) ? doc.telegram : undefined;
+    if (!t)
+        return [{ id: "config.telegram", ok: false, summary: "Invalid config: missing telegram section" }];
+    const token = typeof t.token === "string" ? t.token.trim() : "";
+    const hasToken = token.length > 0;
+    const admins = Array.isArray(t.admin_user_ids) ? t.admin_user_ids : [];
+    const allow = isRecord(t.allowlist) && Array.isArray(t.allowlist.user_ids) ? t.allowlist.user_ids : [];
+    const hasBootstrap = admins.length + allow.length > 0;
+    const out = [];
+    out.push({ id: "config.file", ok: true, summary: `Config file found: ${configPath}` });
+    out.push({ id: "config.telegram.token", ok: hasToken, summary: hasToken ? "telegram.token: present" : "telegram.token: missing" });
+    out.push({
+        id: "config.telegram.bootstrap",
+        ok: hasBootstrap,
+        summary: hasBootstrap ? "bootstrap allowlist: present" : "bootstrap allowlist: missing",
+        details: hasBootstrap ? undefined : "Set telegram.admin_user_ids (or telegram.allowlist.user_ids)."
+    });
+    return out;
+}
+function checkDirs(paths) {
+    const out = [];
+    for (const [id, p] of [
+        ["runtime.data_dir", paths.dataDir],
+        ["runtime.workspaces_dir", paths.workspacesDir],
+        ["runtime.uploads_dir", paths.uploadsDir]
+    ]) {
+        try {
+            node_fs_1.default.mkdirSync(p, { recursive: true });
+            node_fs_1.default.accessSync(p, node_fs_1.default.constants.W_OK);
+            out.push({ id: `dirs.${id}`, ok: true, summary: `${id}: writable (${p})` });
+        }
+        catch (err) {
+            out.push({
+                id: `dirs.${id}`,
+                ok: false,
+                summary: `${id}: not writable (${p})`,
+                details: err instanceof Error ? err.message : String(err)
+            });
+        }
+    }
+    return out;
+}
+function checkSqlite(dataDir) {
+    try {
+        const storage = (0, storage_1.openStorage)(dataDir);
+        return { id: "sqlite.open", ok: true, summary: `SQLite OK (${storage.dbPath() ?? ""})`.trim() };
+    }
+    catch (err) {
+        return {
+            id: "sqlite.open",
+            ok: false,
+            summary: "Failed to open SQLite",
+            details: err instanceof Error ? err.message : String(err)
+        };
+    }
+}
+function checkClaude(binary, env) {
+    const b = binary.trim() || "claude";
+    try {
+        (0, node_child_process_1.execFileSync)(b, ["--version"], {
+            env: { ...process.env, ...env },
+            stdio: "ignore",
+            timeout: 5000
+        });
+        return { id: "claude", ok: true, summary: `claude OK (${b})` };
+    }
+    catch {
+        return {
+            id: "claude",
+            ok: false,
+            summary: `claude failed (${b})`,
+            details: "Ensure Claude Code CLI is installed and available in PATH for the service user."
+        };
+    }
+}

package/dist/core/kayla.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KaylaService = void 0;
+const sessions_1 = require("./sessions");
+const runner_1 = require("./runner");
+const telegram_1 = require("./telegram");
+class Semaphore {
+    constructor(size) {
+        this.waiters = [];
+        this.available = size;
+    }
+    async acquire() {
+        if (this.available > 0) {
+            this.available -= 1;
+            return () => this.release();
+        }
+        return new Promise((resolve) => {
+            this.waiters.push(resolve);
+        });
+    }
+    release() {
+        this.available += 1;
+        const next = this.waiters.shift();
+        if (next && this.available > 0) {
+            this.available -= 1;
+            next(() => this.release());
+        }
+    }
+}
+class KaylaService {
+    constructor(deps) {
+        this.deps = deps;
+        this.chats = new Map();
+        this.semaphore = new Semaphore(this.deps.cfg.jobs.global_concurrency);
+        this.runClaudeImpl = this.deps.runClaudeImpl ?? runner_1.runClaude;
+    }
+    isAllowedTelegramUser(userId) {
+        return this.deps.storage.isAllowedUser("telegram", String(userId));
+    }
+    async handleStartWithUser(chatId, userId) {
+        if (this.isAllowedTelegramUser(userId)) {
+            await this.deps.api.sendMessage(chatId, "Kayla: ready.\n\nCommands: /status /new /reset yes /cancel\nSend a message to run it via Claude Code CLI.");
+            return;
+        }
+        const { code } = this.deps.storage.getOrCreateOnboardingCode("telegram", String(chatId), String(userId));
+        await this.deps.api.sendMessage(chatId, `Access not granted.\n\nCode: ${code}\n\nAsk admin to run:\nkayla telegram users approve ${code}`);
+    }
+    async handleStatus(chatId) {
+        // Status is only for allowlisted users.
+        // Handlers enforce allowlist and ignore non-allowlisted updates.
+        const running = this.deps.storage.getRunningJob(String(chatId));
+        const queued = this.deps.storage.countQueuedJobs(String(chatId));
+        const chat = this.deps.storage.getChat(String(chatId));
+        const lines = [];
+        lines.push(`chat_id: ${chatId}`);
+        lines.push(`running: ${running ? running.job_id : "none"}`);
+        lines.push(`queued: ${queued}`);
+        if (chat) {
+            lines.push(`workspace: ${chat.workspace_path}`);
+            lines.push(`streaming: ${chat.settings.streaming ?? this.deps.cfg.claude.streaming}`);
+            lines.push(`tools: ${chat.settings.tools ?? this.deps.cfg.claude.tools}`);
+            lines.push(`model: ${(chat.settings.model ?? this.deps.cfg.claude.default_model) || "(default)"}`);
+        }
+        await this.deps.api.sendMessage(chatId, lines.join("\n"));
+    }
+    async handleNew(chatId, userId) {
+        if (this.isChatBusy(chatId)) {
+            await this.deps.api.sendMessage(chatId, "Busy: cancel the running job first with /cancel.");
+            return;
+        }
+        const s = (0, sessions_1.createNewSession)(this.deps.storage, this.deps.cfg, chatId, userId);
+        await this.deps.api.sendMessage(chatId, `New session started.\nworkspace: ${s.workspacePath}`);
+    }
+    async handleReset(chatId, userId, confirm) {
+        if (!confirm) {
+            await this.deps.api.sendMessage(chatId, "Reset is destructive. Confirm with: /reset yes");
+            return;
+        }
+        if (this.isChatBusy(chatId)) {
+            await this.deps.api.sendMessage(chatId, "Busy: cancel the running job first with /cancel.");
+            return;
+        }
+        const s = (0, sessions_1.resetSession)(this.deps.storage, this.deps.cfg, chatId, userId);
+        await this.deps.api.sendMessage(chatId, `Session reset.\nworkspace: ${s.workspacePath}`);
+    }
+    async handleCancel(chatId) {
+        const state = this.getChatState(chatId);
+        if (!state.active) {
+            await this.deps.api.sendMessage(chatId, "Nothing to cancel.");
+            return;
+        }
+        state.active.cancel();
+        await this.deps.api.sendMessage(chatId, `Cancel requested: ${state.active.jobId}`);
+    }
+    async enqueueUserMessage(chatId, userId, requestText) {
+        const state = this.getChatState(chatId);
+        const queuedCount = state.queue.length + (state.active ? 1 : 0);
+        if (queuedCount >= this.deps.cfg.jobs.queue_size_per_chat) {
+            await this.deps.api.sendMessage(chatId, "Queue is full for this chat. Please wait or /cancel.");
+            return;
+        }
+        // Ensure chat exists + workspace created.
+        (0, sessions_1.getOrCreateSession)(this.deps.storage, this.deps.cfg, chatId, userId);
+        const job = this.deps.storage.insertJob({ chatId: String(chatId), requestText });
+        state.queue.push({ jobId: job.job_id, chatId, userId, requestText });
+        this.kick(chatId).catch((err) => {
+            this.deps.logger.error({ err, msg: "kick failed", chatId });
+        });
+    }
+    getChatState(chatId) {
+        const existing = this.chats.get(chatId);
+        if (existing)
+            return existing;
+        const s = { queue: [], processing: false };
+        this.chats.set(chatId, s);
+        return s;
+    }
+    isChatBusy(chatId) {
+        const s = this.getChatState(chatId);
+        return !!s.active || s.queue.length > 0 || this.deps.storage.getRunningJob(String(chatId)) !== undefined;
+    }
+    async kick(chatId) {
+        const state = this.getChatState(chatId);
+        if (state.processing)
+            return;
+        state.processing = true;
+        try {
+            while (state.queue.length > 0) {
+                const item = state.queue.shift();
+                const release = await this.semaphore.acquire();
+                try {
+                    await this.runOne(item, state);
+                }
+                catch (err) {
+                    this.deps.logger.error({ err, msg: "job processing failed", chatId: item.chatId, jobId: item.jobId });
+                    // Best-effort mark job as failed so /status isn't stuck.
+                    try {
+                        this.deps.storage.setJobFinished({
+                            jobId: item.jobId,
+                            status: "failed",
+                            error: err instanceof Error ? err.message : "unknown error"
+                        });
+                    }
+                    catch {
+                        // ignore secondary failures
+                    }
+                }
+                finally {
+                    release();
+                }
+            }
+        }
+        finally {
+            state.processing = false;
+        }
+    }
+    async runOne(item, state) {
+        const { chatId, userId, jobId, requestText } = item;
+        const logger = this.deps.logger.child({ chatId, jobId });
+        logger.info({ phase: "enqueue", msg: "starting job" });
+        const chat = this.deps.storage.getChat(String(chatId));
+        const session = (0, sessions_1.getOrCreateSession)(this.deps.storage, this.deps.cfg, chatId, userId);
+        const streaming = chat?.settings.streaming ?? this.deps.cfg.claude.streaming;
+        let messageId;
+        let editor;
+        let assistantSoFar = "";
+        if (streaming) {
+            const placeholder = await this.deps.api.sendMessage(chatId, "...");
+            messageId = placeholder.message_id;
+            this.deps.storage.setJobTelegramMessageId(jobId, messageId);
+            editor = new telegram_1.ThrottledTelegramEditor(this.deps.api, chatId, messageId, 1000, logger);
+        }
+        this.deps.storage.setJobRunning(jobId);
+        const running = this.runClaudeImpl({
+            cfg: this.deps.cfg,
+            cwd: session.workspacePath,
+            prompt: requestText,
+            chatSettings: chat?.settings,
+            onTextDelta: (delta) => {
+                assistantSoFar += delta;
+                if (editor)
+                    editor.request(assistantSoFar);
+            },
+            logger
+        });
+        state.active = { jobId, cancel: running.cancel };
+        let resultStatus = "succeeded";
+        let resultError = null;
+        let exitCode = null;
+        let stderr = "";
+        try {
+            const res = await running.promise;
+            exitCode = res.exitCode;
+            stderr = res.stderr;
+            if (res.timedOut) {
+                resultStatus = "timeout";
+                resultError = "timeout";
+            }
+            else if (res.canceled) {
+                resultStatus = "canceled";
+                resultError = "canceled";
+            }
+            else if (res.exitCode !== 0) {
+                resultStatus = "failed";
+                resultError = `exit_code=${res.exitCode}`;
+            }
+            if (!assistantSoFar)
+                assistantSoFar = res.assistantText;
+        }
+        catch (err) {
+            resultStatus = "failed";
+            resultError = err instanceof Error ? err.message : "unknown error";
+        }
+        finally {
+            state.active = undefined;
+        }
+        logger.info({ phase: "finish", status: resultStatus, exitCode, msg: "job finished" });
+        if (stderr)
+            logger.debug({ stderr, msg: "claude stderr" });
+        this.deps.storage.setJobFinished({ jobId, status: resultStatus, responseText: assistantSoFar, error: resultError, exitCode });
+        if (streaming && messageId && editor) {
+            editor.request(assistantSoFar || "(no output)");
+            await editor.flush();
+            // If too long, send remaining chunks as additional messages.
+            const finalText = assistantSoFar || "(no output)";
+            const parts = (0, telegram_1.splitTelegramText)(finalText);
+            if (parts.length > 1) {
+                // Keep the edited message readable (first chunk), send the rest.
+                await this.deps.api.editMessageText(chatId, messageId, (0, telegram_1.truncateForEdit)(parts[0]));
+                for (const p of parts.slice(1)) {
+                    await this.deps.api.sendMessage(chatId, p);
+                }
+            }
+            if (resultStatus === "failed") {
+                await this.deps.api.sendMessage(chatId, `Job failed (${jobId}).`);
+            }
+            else if (resultStatus === "timeout") {
+                await this.deps.api.sendMessage(chatId, `Job timed out (${jobId}).`);
+            }
+            else if (resultStatus === "canceled") {
+                await this.deps.api.sendMessage(chatId, `Canceled (${jobId}).`);
+            }
+            return;
+        }
+        // Non-streaming: send one or multiple messages after completion.
+        const finalText = assistantSoFar || "(no output)";
+        for (const p of (0, telegram_1.splitTelegramText)(finalText)) {
+            await this.deps.api.sendMessage(chatId, p);
+        }
+        if (resultStatus !== "succeeded") {
+            await this.deps.api.sendMessage(chatId, `Job ${resultStatus} (${jobId}).`);
+        }
+    }
+}
+exports.KaylaService = KaylaService;

package/dist/core/logging.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = createLogger;
+const pino_1 = __importDefault(require("pino"));
+function createLogger(cfg) {
+    return (0, pino_1.default)({
+        level: cfg.level,
+        // If json=false, we still log JSON objects; pino-pretty can be added later.
+        base: null
+    });
+}

package/dist/core/parser.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryParseJson = tryParseJson;
+exports.extractTextPieces = extractTextPieces;
+exports.appendStreamJsonLine = appendStreamJsonLine;
+exports.extractAssistantTextFromJsonOutput = extractAssistantTextFromJsonOutput;
+function tryParseJson(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isRecord(v) {
+    return !!v && typeof v === "object" && !Array.isArray(v);
+}
+function extractTextFromContentArray(v) {
+    if (!Array.isArray(v))
+        return undefined;
+    const parts = [];
+    for (const item of v) {
+        if (!isRecord(item))
+            continue;
+        const type = item.type;
+        if (type === "text" && typeof item.text === "string") {
+            parts.push(item.text);
+            continue;
+        }
+        if (typeof item.text === "string")
+            parts.push(item.text);
+        if (typeof item.value === "string")
+            parts.push(item.value);
+    }
+    return parts.length ? parts.join("") : undefined;
+}
+function extractTextPieces(event) {
+    if (!isRecord(event))
+        return [];
+    // Priority-ish search (best-effort) based on the task requirements.
+    const msg = event.message;
+    if (isRecord(msg)) {
+        const content = msg.content;
+        if (typeof content === "string")
+            return [content];
+        const fromArray = extractTextFromContentArray(content);
+        if (typeof fromArray === "string" && fromArray.length)
+            return [fromArray];
+    }
+    const delta = event.delta;
+    if (isRecord(delta) && typeof delta.text === "string" && delta.text.length)
+        return [delta.text];
+    const content = event.content;
+    if (isRecord(content) && typeof content.text === "string" && content.text.length)
+        return [content.text];
+    const contentFromArray = extractTextFromContentArray(content);
+    if (typeof contentFromArray === "string" && contentFromArray.length)
+        return [contentFromArray];
+    // Fallback: crawl a few common shapes without being too clever.
+    const parts = [];
+    for (const k of ["text", "value"]) {
+        const v = event[k];
+        if (typeof v === "string")
+            parts.push(v);
+    }
+    return parts;
+}
+function appendStreamJsonLine(opts) {
+    const parsed = tryParseJson(opts.line);
+    if (parsed === undefined) {
+        opts.onWarn?.("non-json line");
+        return;
+    }
+    const pieces = extractTextPieces(parsed);
+    for (const p of pieces) {
+        if (p)
+            opts.onText(p);
+    }
+}
+function extractAssistantTextFromJsonOutput(v) {
+    const pieces = extractTextPieces(v);
+    if (pieces.length)
+        return pieces.join("");
+    // Some CLIs wrap the final content in { message: { content: [...] } } etc.
+    if (isRecord(v) && isRecord(v.result)) {
+        const inner = extractTextPieces(v.result);
+        if (inner.length)
+            return inner.join("");
+    }
+    return "";
+}

package/dist/core/runner.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildClaudeArgs = buildClaudeArgs;
+exports.runClaude = runClaude;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_child_process_1 = require("node:child_process");
+const node_readline_1 = __importDefault(require("node:readline"));
+const parser_1 = require("./parser");
+function fileExists(p) {
+    try {
+        return node_fs_1.default.existsSync(p);
+    }
+    catch {
+        return false;
+    }
+}
+function buildClaudeArgs(cfg, prompt, chatSettings) {
+    const args = [];
+    args.push("-c", "-p");
+    const outputFormat = cfg.claude.streaming ? "stream-json" : "json";
+    args.push("--output-format", outputFormat);
+    // Chat-level overrides (optional).
+    const tools = chatSettings?.tools ?? cfg.claude.tools;
+    const model = chatSettings?.model ?? cfg.claude.default_model;
+    if (model && model.length)
+        args.push("--model", model);
+    args.push("--max-turns", String(cfg.claude.max_turns));
+    args.push("--tools", tools);
+    if (cfg.claude.mcp?.config_file) {
+        args.push("--mcp-config", cfg.claude.mcp.config_file);
+        if (cfg.claude.mcp.strict)
+            args.push("--strict-mcp-config");
+    }
+    if (cfg.claude.append_system_prompt_file) {
+        args.push("--append-system-prompt-file", cfg.claude.append_system_prompt_file);
+    }
+    if (cfg.claude.agents_file) {
+        const agentsJson = node_fs_1.default.readFileSync(cfg.claude.agents_file, "utf8");
+        args.push("--agents", agentsJson);
+    }
+    args.push(prompt);
+    return args;
+}
+function runClaude(opts) {
+    // Validate optional files early for clearer errors.
+    if (opts.cfg.claude.append_system_prompt_file && !fileExists(opts.cfg.claude.append_system_prompt_file)) {
+        throw new Error(`append_system_prompt_file not found: ${opts.cfg.claude.append_system_prompt_file}`);
+    }
+    if (opts.cfg.claude.agents_file && !fileExists(opts.cfg.claude.agents_file)) {
+        throw new Error(`agents_file not found: ${opts.cfg.claude.agents_file}`);
+    }
+    if (opts.cfg.claude.mcp?.config_file && !fileExists(opts.cfg.claude.mcp.config_file)) {
+        throw new Error(`mcp config_file not found: ${opts.cfg.claude.mcp.config_file}`);
+    }
+    const args = buildClaudeArgs(opts.cfg, opts.prompt, opts.chatSettings);
+    const child = (0, node_child_process_1.spawn)(opts.cfg.claude.binary, args, { cwd: opts.cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let assistantText = "";
+    let stderr = "";
+    let canceled = false;
+    let timedOut = false;
+    let killTimer;
+    let hardKillTimer;
+    let settled = false;
+    let spawnError = null;
+    child.stderr.on("data", (buf) => {
+        stderr += buf.toString("utf8");
+    });
+    child.on("error", (err) => {
+        spawnError = err instanceof Error ? err.message : "spawn error";
+        // Close might not fire on spawn errors; resolve via promise handler below.
+    });
+    const outputFormat = opts.cfg.claude.streaming ? "stream-json" : "json";
+    if (outputFormat === "stream-json") {
+        const rl = node_readline_1.default.createInterface({ input: child.stdout });
+        rl.on("line", (line) => {
+            (0, parser_1.appendStreamJsonLine)({
+                line,
+                onText: (delta) => {
+                    assistantText += delta;
+                    opts.onTextDelta?.(delta);
+                },
+                onWarn: (msg) => opts.logger?.debug({ msg, line }, "stream-json parse warn")
+            });
+        });
+    }
+    else {
+        let stdout = "";
+        child.stdout.on("data", (buf) => {
+            stdout += buf.toString("utf8");
+        });
+        child.on("close", () => {
+            // Parse at end (best effort).
+            const parsed = (0, parser_1.tryParseJson)(stdout);
+            if (parsed !== undefined)
+                assistantText = (0, parser_1.extractAssistantTextFromJsonOutput)(parsed);
+        });
+    }
+    const cancel = () => {
+        if (child.killed)
+            return;
+        canceled = true;
+        child.kill("SIGTERM");
+        hardKillTimer = setTimeout(() => {
+            if (!child.killed)
+                child.kill("SIGKILL");
+        }, 5000);
+    };
+    killTimer = setTimeout(() => {
+        timedOut = true;
+        cancel();
+    }, opts.cfg.claude.timeout_seconds * 1000);
+    const promise = new Promise((resolve) => {
+        const finalize = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            if (killTimer)
+                clearTimeout(killTimer);
+            if (hardKillTimer)
+                clearTimeout(hardKillTimer);
+            if (spawnError && !stderr)
+                stderr = spawnError;
+            resolve({ assistantText, exitCode: code, timedOut, canceled, stderr });
+        };
+        child.on("close", (code) => finalize(code));
+        child.on("error", () => finalize(null));
+    });
+    return { promise, cancel };
+}

package/dist/core/security.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAllowedUser = isAllowedUser;
+function isAllowedUser(allowlist, userId) {
+    return allowlist.includes(userId);
+}