comisai 1.0.4

package/node_modules/@comis/cli/dist/wizard/steps/06-channels.js

@@ -0,0 +1,476 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Channel setup step -- step 06 of the init wizard.
+ *
+ * Presents a multiselect of all 7 supported channels with credential hints,
+ * collects per-channel credentials inline with format pre-checks and live
+ * API validation, shows deferred guidance for WhatsApp/Signal, silently
+ * adds IRC, and stores ChannelConfig[] on wizard state.
+ *
+ * Live validation uses native fetch (Node 22+) with AbortController
+ * timeouts, matching the pattern from 04-credentials.ts.
+ *
+ * @module
+ */
+import { updateState, sectionSeparator, info, SUPPORTED_CHANNELS, validateChannelCredential, } from "../index.js";
+// ---------- Live Validation Functions ----------
+/**
+ * Validate a Telegram bot token via the getMe API.
+ *
+ * GET https://api.telegram.org/bot{token}/getMe
+ */
+async function validateTelegramLive(token) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    try {
+        const response = await fetch(`https://api.telegram.org/bot${token}/getMe`, { method: "GET", signal: controller.signal });
+        if (response.ok) {
+            const data = (await response.json());
+            return { valid: true, username: data.result.username, id: data.result.id };
+        }
+        if (response.status === 401 || response.status === 403) {
+            return { valid: false, error: "Invalid bot token" };
+        }
+        return { valid: false, error: `Telegram API returned ${response.status}` };
+    }
+    catch {
+        return { valid: false, error: "Could not reach Telegram API" };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/**
+ * Validate a Discord bot token via /users/@me.
+ *
+ * GET https://discord.com/api/v10/users/@me with Authorization: Bot {token}
+ */
+async function validateDiscordLive(token) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    try {
+        const response = await fetch("https://discord.com/api/v10/users/@me", {
+            method: "GET",
+            headers: { Authorization: `Bot ${token}` },
+            signal: controller.signal,
+        });
+        if (response.ok) {
+            const data = (await response.json());
+            return { valid: true, username: data.username, discriminator: data.discriminator };
+        }
+        if (response.status === 401 || response.status === 403) {
+            return { valid: false, error: "Invalid bot token" };
+        }
+        return { valid: false, error: `Discord API returned ${response.status}` };
+    }
+    catch {
+        return { valid: false, error: "Could not reach Discord API" };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/**
+ * Validate a Slack bot token via auth.test.
+ *
+ * POST https://slack.com/api/auth.test with Authorization: Bearer {botToken}
+ */
+async function validateSlackLive(botToken) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    try {
+        const response = await fetch("https://slack.com/api/auth.test", {
+            method: "POST",
+            headers: { Authorization: `Bearer ${botToken}` },
+            signal: controller.signal,
+        });
+        if (response.ok) {
+            const data = (await response.json());
+            if (data.ok) {
+                return { valid: true };
+            }
+            return { valid: false, error: data.error ?? "Auth test failed" };
+        }
+        return { valid: false, error: `Slack API returned ${response.status}` };
+    }
+    catch {
+        return { valid: false, error: "Could not reach Slack API" };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/**
+ * Validate a LINE channel access token via getBotInfo.
+ *
+ * GET https://api.line.me/v2/bot/info with Authorization: Bearer {channelToken}
+ */
+async function validateLineLive(channelToken) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    try {
+        const response = await fetch("https://api.line.me/v2/bot/info", {
+            method: "GET",
+            headers: { Authorization: `Bearer ${channelToken}` },
+            signal: controller.signal,
+        });
+        if (response.ok) {
+            const data = (await response.json());
+            return { valid: true, displayName: data.displayName };
+        }
+        if (response.status === 401 || response.status === 403) {
+            return { valid: false, error: "Invalid channel token" };
+        }
+        return { valid: false, error: `LINE API returned ${response.status}` };
+    }
+    catch {
+        return { valid: false, error: "Could not reach LINE API" };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+// ---------- Per-Channel Handlers ----------
+/**
+ * Collect Discord bot token and optional guild IDs with live validation.
+ */
+async function handleDiscord(prompter) {
+    prompter.note(sectionSeparator("Discord Setup"));
+    prompter.note(info("Create at: https://discord.com/developers/applications"));
+    const maxRetries = 3;
+    let validatedToken = null;
+    let validated = false;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        const token = await prompter.password({
+            message: "Discord bot token",
+            validate: (v) => {
+                if (typeof v !== "string")
+                    return undefined;
+                const result = validateChannelCredential("discord", "botToken", v);
+                return result?.message;
+            },
+        });
+        const spin = prompter.spinner();
+        spin.start("Validating token...");
+        const result = await validateDiscordLive(token);
+        if (result.valid) {
+            const display = result.discriminator && result.discriminator !== "0"
+                ? `${result.username}#${result.discriminator}`
+                : result.username;
+            spin.stop(`Bot: ${display}`);
+            validatedToken = token;
+            validated = true;
+            break;
+        }
+        spin.stop("Validation failed");
+        prompter.log.warn(result.error ?? "Unknown validation error");
+        const isLastAttempt = attempt === maxRetries;
+        const recoveryOptions = isLastAttempt
+            ? [
+                { value: "continue", label: "Continue anyway", hint: "Not recommended" },
+                { value: "skip", label: "Skip Discord" },
+            ]
+            : [
+                { value: "retry", label: "Try again" },
+                { value: "continue", label: "Continue anyway", hint: "Not recommended" },
+                { value: "skip", label: "Skip Discord" },
+            ];
+        const choice = await prompter.select({
+            message: "What would you like to do?",
+            options: recoveryOptions,
+        });
+        if (choice === "continue") {
+            validatedToken = token;
+            validated = false;
+            break;
+        }
+        if (choice === "skip") {
+            return null;
+        }
+        // retry -- continue loop
+    }
+    if (validatedToken === null) {
+        return null;
+    }
+    // Prompt for guild IDs
+    const guildInput = await prompter.text({
+        message: "Discord guild IDs (comma-separated, or blank for all)",
+        defaultValue: "",
+    });
+    const guildIds = guildInput
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    return { type: "discord", botToken: validatedToken, guildIds, validated };
+}
+/**
+ * Collect Slack bot token and app token with live validation.
+ */
+async function handleSlack(prompter) {
+    prompter.note(sectionSeparator("Slack Setup"));
+    const maxRetries = 3;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        const botToken = await prompter.password({
+            message: "Slack bot token (xoxb-...)",
+            validate: (v) => {
+                if (typeof v !== "string")
+                    return undefined;
+                const result = validateChannelCredential("slack", "botToken", v);
+                return result?.message;
+            },
+        });
+        const appToken = await prompter.password({
+            message: "Slack app token (xapp-...)",
+            validate: (v) => {
+                if (typeof v !== "string")
+                    return undefined;
+                const result = validateChannelCredential("slack", "appToken", v);
+                return result?.message;
+            },
+        });
+        const spin = prompter.spinner();
+        spin.start("Validating tokens...");
+        const result = await validateSlackLive(botToken);
+        if (result.valid) {
+            spin.stop("Workspace verified");
+            return { type: "slack", botToken, appToken, validated: true };
+        }
+        spin.stop("Validation failed");
+        prompter.log.warn(result.error ?? "Unknown validation error");
+        const isLastAttempt = attempt === maxRetries;
+        const recoveryOptions = isLastAttempt
+            ? [
+                { value: "continue", label: "Continue anyway", hint: "Not recommended" },
+                { value: "skip", label: "Skip Slack" },
+            ]
+            : [
+                { value: "retry", label: "Try again" },
+                { value: "continue", label: "Continue anyway", hint: "Not recommended" },
+                { value: "skip", label: "Skip Slack" },
+            ];
+        const choice = await prompter.select({
+            message: "What would you like to do?",
+            options: recoveryOptions,
+        });
+        if (choice === "continue") {
+            return { type: "slack", botToken, appToken, validated: false };
+        }
+        if (choice === "skip") {
+            return null;
+        }
+        // retry -- continue loop
+    }
+    return null;
+}
+/**
+ * Collect LINE channel access token and secret with live validation.
+ */
+async function handleLine(prompter) {
+    prompter.note(sectionSeparator("LINE Setup"));
+    prompter.note(info("Get from LINE Developers Console -> Messaging API"));
+    const maxRetries = 3;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        const channelToken = await prompter.password({
+            message: "LINE channel access token",
+            validate: (v) => {
+                if (typeof v !== "string")
+                    return undefined;
+                const result = validateChannelCredential("line", "channelToken", v);
+                return result?.message;
+            },
+        });
+        const channelSecret = await prompter.password({
+            message: "LINE channel secret",
+            validate: (v) => {
+                if (typeof v !== "string")
+                    return undefined;
+                const result = validateChannelCredential("line", "channelSecret", v);
+                return result?.message;
+            },
+        });
+        const spin = prompter.spinner();
+        spin.start("Validating token...");
+        const result = await validateLineLive(channelToken);
+        if (result.valid) {
+            spin.stop(`Bot: ${result.displayName}`);
+            return { type: "line", botToken: channelToken, channelSecret, validated: true };
+        }
+        spin.stop("Validation failed");
+        prompter.log.warn(result.error ?? "Unknown validation error");
+        const isLastAttempt = attempt === maxRetries;
+        const recoveryOptions = isLastAttempt
+            ? [
+                { value: "continue", label: "Continue anyway", hint: "Not recommended" },
+                { value: "skip", label: "Skip LINE" },
+            ]
+            : [
+                { value: "retry", label: "Try again" },
+                { value: "continue", label: "Continue anyway", hint: "Not recommended" },
+                { value: "skip", label: "Skip LINE" },
+            ];
+        const choice = await prompter.select({
+            message: "What would you like to do?",
+            options: recoveryOptions,
+        });
+        if (choice === "continue") {
+            return { type: "line", botToken: channelToken, channelSecret, validated: false };
+        }
+        if (choice === "skip") {
+            return null;
+        }
+        // retry -- continue loop
+    }
+    return null;
+}
+/**
+ * WhatsApp: deferred configuration guidance.
+ */
+function handleWhatsApp(prompter) {
+    prompter.note(info("WhatsApp will be configured after setup.\nRun `comis channel whatsapp-pair` to scan the QR code."), "WhatsApp");
+    return { type: "whatsapp", validated: false };
+}
+/**
+ * Signal: deferred configuration guidance.
+ */
+function handleSignal(prompter) {
+    prompter.note(info("Signal requires signal-cli.\nRun `comis signal-setup` for guided installation."), "Signal");
+    return { type: "signal", validated: false };
+}
+/**
+ * IRC: auto-configured with defaults, no credentials needed.
+ */
+function handleIrc(prompter) {
+    prompter.log.info("IRC added with default configuration (no credentials needed).");
+    return { type: "irc", validated: true };
+}
+/**
+ * Telegram handler that also returns the validated bot ID for use
+ * as a placeholder hint in the sender trust prompt.
+ */
+async function handleTelegramWithId(prompter) {
+    prompter.note(sectionSeparator("Telegram Setup"));
+    prompter.note(info("Create a bot via @BotFather -> /newbot -> copy the token"));
+    const maxRetries = 3;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        const token = await prompter.password({
+            message: "Telegram bot token",
+            validate: (v) => {
+                if (typeof v !== "string")
+                    return undefined;
+                const result = validateChannelCredential("telegram", "botToken", v);
+                return result?.message;
+            },
+        });
+        const spin = prompter.spinner();
+        spin.start("Validating token...");
+        const result = await validateTelegramLive(token);
+        if (result.valid) {
+            spin.stop(`Bot: @${result.username} (ID: ${result.id})`);
+            return {
+                config: { type: "telegram", botToken: token, validated: true },
+            };
+        }
+        spin.stop("Validation failed");
+        prompter.log.warn(result.error ?? "Unknown validation error");
+        const isLastAttempt = attempt === maxRetries;
+        const recoveryOptions = isLastAttempt
+            ? [
+                { value: "continue", label: "Continue anyway", hint: "Not recommended" },
+                { value: "skip", label: "Skip Telegram" },
+            ]
+            : [
+                { value: "retry", label: "Try again" },
+                { value: "continue", label: "Continue anyway", hint: "Not recommended" },
+                { value: "skip", label: "Skip Telegram" },
+            ];
+        const choice = await prompter.select({
+            message: "What would you like to do?",
+            options: recoveryOptions,
+        });
+        if (choice === "continue") {
+            return { config: { type: "telegram", botToken: token, validated: false } };
+        }
+        if (choice === "skip") {
+            return { config: null };
+        }
+        // retry -- continue loop
+    }
+    return { config: null };
+}
+async function handleChannel(channelType, prompter) {
+    switch (channelType) {
+        case "telegram":
+            return handleTelegramWithId(prompter);
+        case "discord":
+            return { config: await handleDiscord(prompter) };
+        case "slack":
+            return { config: await handleSlack(prompter) };
+        case "line":
+            return { config: await handleLine(prompter) };
+        case "whatsapp":
+            return { config: handleWhatsApp(prompter) };
+        case "signal":
+            return { config: handleSignal(prompter) };
+        case "irc":
+            return { config: handleIrc(prompter) };
+        default:
+            return { config: null };
+    }
+}
+// ---------- Step Implementation ----------
+export const channelsStep = {
+    id: "channels",
+    label: "Channel Setup",
+    async execute(state, prompter) {
+        prompter.note(sectionSeparator("Channel Setup"));
+        // 1. Channel multiselect
+        const selected = await prompter.multiselect({
+            message: "Connect chat channels (select all that apply)",
+            options: SUPPORTED_CHANNELS.map((ch) => ({
+                value: ch.type,
+                label: ch.label,
+                hint: ch.credentialHint,
+            })),
+            required: false,
+        });
+        if (selected.length === 0) {
+            if (state.channels && state.channels.length > 0) {
+                prompter.log.info("Keeping existing channel configuration.");
+            }
+            else {
+                prompter.log.info("No channels selected -- you can add them later.");
+            }
+            return state;
+        }
+        // 2. Per-channel credential collection
+        const configs = [];
+        for (const channelType of selected) {
+            const result = await handleChannel(channelType, prompter);
+            if (result.config !== null) {
+                configs.push(result.config);
+            }
+        }
+        // 3. Sender trust prompt (only when channels were configured)
+        if (configs.length > 0) {
+            const wantTrust = await prompter.confirm({
+                message: "Grant admin access to specific senders?",
+            });
+            if (wantTrust) {
+                prompter.note(info("Enter YOUR user ID (not the bot ID).\nTelegram: message @userinfobot to get yours.\nDiscord: enable Developer Mode → right-click your name → Copy User ID."));
+                const input = await prompter.text({
+                    message: "Your sender IDs (comma-separated)",
+                    placeholder: "e.g. 678314278",
+                    validate: (v) => v.trim().length === 0 ? "At least one sender ID required" : undefined,
+                });
+                const entries = input
+                    .split(",")
+                    .map((s) => s.trim())
+                    .filter((s) => s.length > 0)
+                    .map((senderId) => ({ senderId, level: "admin" }));
+                return updateState(state, { channels: configs, senderTrustEntries: entries });
+            }
+        }
+        // 4. Return state with collected channel configs
+        return updateState(state, { channels: configs });
+    },
+};

package/node_modules/@comis/cli/dist/wizard/steps/07-gateway.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Gateway configuration step -- step 07 of the init wizard.
+ *
+ * Collects network and security settings for the daemon gateway:
+ * port (default 4766), bind mode (loopback/LAN/custom IP), and
+ * authentication method (auto-generated token or user-chosen password).
+ *
+ * Token auth generates a 48-char hex token via crypto.randomBytes.
+ * Custom IP bind mode validates the address via validateIpAddress.
+ *
+ * @module
+ */
+import type { WizardStep } from "../index.js";
+export declare const gatewayStep: WizardStep;

package/node_modules/@comis/cli/dist/wizard/steps/07-gateway.js

@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Gateway configuration step -- step 07 of the init wizard.
+ *
+ * Collects network and security settings for the daemon gateway:
+ * port (default 4766), bind mode (loopback/LAN/custom IP), and
+ * authentication method (auto-generated token or user-chosen password).
+ *
+ * Token auth generates a 48-char hex token via crypto.randomBytes.
+ * Custom IP bind mode validates the address via validateIpAddress.
+ *
+ * @module
+ */
+import { randomBytes } from "node:crypto";
+import { updateState, sectionSeparator, validatePort, validateIpAddress, } from "../index.js";
+// ---------- Step Implementation ----------
+export const gatewayStep = {
+    id: "gateway",
+    label: "Gateway Configuration",
+    async execute(state, prompter) {
+        prompter.note(sectionSeparator("Gateway Configuration"));
+        // 1. Port prompt
+        const portInput = await prompter.text({
+            message: "Gateway port",
+            placeholder: state.gateway?.port ? String(state.gateway.port) : "4766",
+            defaultValue: state.gateway?.port ? String(state.gateway.port) : "4766",
+            required: true,
+            validate: (value) => {
+                if (typeof value !== "string")
+                    return undefined;
+                const result = validatePort(value);
+                return result ? result.message : undefined;
+            },
+        });
+        const port = Number(portInput);
+        // 2. Bind mode prompt
+        const bindMode = await prompter.select({
+            message: "Gateway bind mode",
+            options: [
+                { value: "loopback", label: "Loopback only (127.0.0.1)", hint: "Safest -- local access only" },
+                { value: "lan", label: "LAN (0.0.0.0)", hint: "Accessible from local network" },
+                { value: "custom", label: "Custom IP", hint: "Bind to a specific interface" },
+            ],
+            initialValue: state.gateway?.bindMode ?? "loopback",
+        });
+        // 3. Security hints and custom IP
+        let customIp;
+        if (bindMode === "lan") {
+            prompter.log.warn("LAN mode exposes the gateway to your local network. Use token auth and a firewall.");
+        }
+        if (bindMode === "custom") {
+            customIp = await prompter.text({
+                message: "Bind IP address",
+                placeholder: state.gateway?.customIp ?? "192.168.1.100",
+                defaultValue: state.gateway?.customIp,
+                validate: (value) => {
+                    if (typeof value !== "string")
+                        return undefined;
+                    const result = validateIpAddress(value);
+                    return result ? result.message : undefined;
+                },
+            });
+        }
+        // 4. Auth method prompt
+        const authMethod = await prompter.select({
+            message: "Authentication method",
+            options: [
+                { value: "token", label: "Token (recommended)", hint: "Auto-generated 48-char hex token" },
+                { value: "password", label: "Password", hint: "You choose a password" },
+            ],
+            initialValue: state.gateway?.authMethod ?? "token",
+        });
+        // 5. Token generation or password prompt
+        let token;
+        let password;
+        if (authMethod === "token") {
+            token = randomBytes(24).toString("hex");
+            prompter.log.info(`Gateway token: ${token}`);
+            prompter.log.info("Save this token -- you'll need it for remote access.");
+        }
+        else {
+            password = await prompter.password({
+                message: "Gateway password",
+                validate: (value) => {
+                    if (typeof value !== "string")
+                        return undefined;
+                    if (value.length < 8) {
+                        return "Password must be at least 8 characters.";
+                    }
+                    return undefined;
+                },
+            });
+        }
+        // 6. Build config and update state
+        const config = {
+            port,
+            bindMode: bindMode,
+            ...(customIp !== undefined && { customIp }),
+            authMethod: authMethod,
+            ...(token !== undefined && { token }),
+            ...(password !== undefined && { password }),
+        };
+        return updateState(state, { gateway: config });
+    },
+};

package/node_modules/@comis/cli/dist/wizard/steps/08-workspace.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Workspace directory step -- step 08 of the init wizard.
+ *
+ * Collects the data directory path where agent memory, sessions,
+ * and logs are stored. Shows available disk space via statfs in
+ * human-readable format. Default path is ~/.comis/data.
+ *
+ * Disk space detection fails gracefully -- the wizard continues
+ * even if statfs errors (e.g., path does not exist yet).
+ *
+ * @module
+ */
+import type { WizardStep } from "../index.js";
+export declare const workspaceStep: WizardStep;

package/node_modules/@comis/cli/dist/wizard/steps/08-workspace.js

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Workspace directory step -- step 08 of the init wizard.
+ *
+ * Collects the data directory path where agent memory, sessions,
+ * and logs are stored. Shows available disk space via statfs in
+ * human-readable format. Default path is ~/.comis/data.
+ *
+ * Disk space detection fails gracefully -- the wizard continues
+ * even if statfs errors (e.g., path does not exist yet).
+ *
+ * @module
+ */
+import { statfs } from "node:fs/promises";
+import { homedir } from "node:os";
+import { updateState, sectionSeparator } from "../index.js";
+// ---------- Helpers ----------
+/**
+ * Format bytes into human-readable string.
+ *
+ * Uses binary units (1 GB = 1024^3 bytes) to match
+ * what users expect from disk space displays.
+ */
+function formatBytes(bytes) {
+    const TB = 1024 ** 4;
+    const GB = 1024 ** 3;
+    const MB = 1024 ** 2;
+    if (bytes >= TB)
+        return `${(bytes / TB).toFixed(1)} TB`;
+    if (bytes >= GB)
+        return `${(bytes / GB).toFixed(1)} GB`;
+    if (bytes >= MB)
+        return `${(bytes / MB).toFixed(0)} MB`;
+    return `${bytes} bytes`;
+}
+// ---------- Step Implementation ----------
+export const workspaceStep = {
+    id: "workspace",
+    label: "Workspace",
+    async execute(state, prompter) {
+        prompter.note(sectionSeparator("Workspace"));
+        const defaultDir = `${homedir()}/.comis`;
+        // 1. Detect disk space (best-effort, never blocks wizard)
+        let diskSpaceInfo;
+        try {
+            // Use homedir as the statfs target since the default path may not exist yet
+            const stats = await statfs(homedir());
+            const availableBytes = stats.bavail * stats.bsize;
+            diskSpaceInfo = formatBytes(availableBytes);
+        }
+        catch {
+            // statfs failed -- skip disk space display
+        }
+        // 2. Show info messages
+        prompter.log.info("Agent memory, sessions, and logs are stored here.");
+        if (diskSpaceInfo) {
+            prompter.log.info(`Disk space: ${diskSpaceInfo} available`);
+        }
+        // 3. Directory prompt
+        const dirInput = await prompter.text({
+            message: "Data directory",
+            placeholder: state.dataDir ?? defaultDir,
+            defaultValue: state.dataDir ?? defaultDir,
+            required: true,
+        });
+        const selectedDir = dirInput.trim() || defaultDir;
+        return updateState(state, { dataDir: selectedDir });
+    },
+};