opencode-claw 0.1.0 → 0.2.1

package/README.md

@@ -51,8 +51,7 @@ opencode-claw
 
 ```bash
 # 1. Create a config file in your project directory
-curl -O https://raw.githubusercontent.com/jinkoso/opencode-claw/main/opencode-claw.example.json
-mv opencode-claw.example.json opencode-claw.json
+npx opencode-claw --init
 
 # 2. Edit opencode-claw.json with your tokens and preferences
 #    (see Configuration section below)
@@ -61,6 +60,8 @@ mv opencode-claw.example.json opencode-claw.json
 npx opencode-claw
 ```
 
+Or create `opencode-claw.json` manually — see the [example config](https://github.com/jinkoso/opencode-claw/blob/main/opencode-claw.example.json) for all available options.
+
 The service starts an OpenCode server, connects your configured channels, initializes the memory system, and begins listening for messages.
 
 ## Configuration

package/dist/channels/router.d.ts

@@ -1,4 +1,4 @@
-import type { OpencodeClient } from "@opencode-ai/sdk";
+import type { OpencodeClient } from "@opencode-ai/sdk/v2";
 import type { Config } from "../config/types.js";
 import type { SessionManager } from "../sessions/manager.js";
 import type { Logger } from "../utils/logger.js";

package/dist/channels/router.js

@@ -1,4 +1,5 @@
 import { buildSessionKey } from "../sessions/manager.js";
+import { promptStreaming } from "../sessions/prompt.js";
 function allowlist(config, channel) {
     const ch = config.channels[channel];
     if (!ch)
@@ -17,16 +18,10 @@ function rejection(config, channel) {
 }
 function checkAllowlist(config, msg) {
     const list = allowlist(config, msg.channel);
-    if (!list)
+    if (!list || list.length === 0)
         return true;
     return list.includes(msg.peerId);
 }
-function extractText(parts) {
-    return parts
-        .filter((p) => p.type === "text" && typeof p.text === "string")
-        .map((p) => p.text)
-        .join("\n\n");
-}
 function parseCommand(text) {
     const trimmed = text.trim();
     if (!trimmed.startsWith("/"))
@@ -42,8 +37,13 @@ const HELP_TEXT = `Available commands:
 /sessions — List your sessions
 /current — Show current session
 /fork — Fork current session into a new one
+/cancel — Abort the currently running agent
 /help — Show this help`;
-async function handleCommand(cmd, msg, deps) {
+// peerKey uniquely identifies a peer within a channel for active-stream tracking
+function peerKey(channel, peerId) {
+    return `${channel}:${peerId}`;
+}
+async function handleCommand(cmd, msg, deps, activeStreams) {
     const key = buildSessionKey(msg.channel, msg.peerId, msg.threadId);
     const prefix = `${msg.channel}:${msg.peerId}`;
     switch (cmd.name) {
@@ -79,8 +79,7 @@ async function handleCommand(cmd, msg, deps) {
             if (!current)
                 return "No active session to fork.";
             const result = await deps.client.session.fork({
-                path: { id: current },
-                body: {},
+                sessionID: current,
             });
             if (!result.data)
                 return "Fork failed: no data returned.";
@@ -88,6 +87,16 @@ async function handleCommand(cmd, msg, deps) {
             await deps.sessions.switchSession(key, forked);
             return `Forked into new session: ${forked}`;
         }
+        case "cancel": {
+            const pk = peerKey(msg.channel, msg.peerId);
+            const sessionId = activeStreams.get(pk);
+            if (!sessionId)
+                return "No agent is currently running.";
+            const result = await deps.client.session.abort({ sessionID: sessionId });
+            const aborted = result.data ?? false;
+            deps.logger.info("router: session aborted by user", { sessionId, aborted });
+            return aborted ? "Agent aborted." : "Abort request sent (agent may already be done).";
+        }
         case "help": {
             return HELP_TEXT;
         }
@@ -96,7 +105,7 @@ async function handleCommand(cmd, msg, deps) {
         }
     }
 }
-async function routeMessage(msg, deps) {
+async function routeMessage(msg, deps, activeStreams, pendingQuestions) {
     const adapter = deps.adapters.get(msg.channel);
     if (!adapter) {
         deps.logger.warn("router: no adapter for channel", { channel: msg.channel });
@@ -117,7 +126,7 @@ async function routeMessage(msg, deps) {
     // Command interception
     const cmd = parseCommand(msg.text);
     if (cmd) {
-        const reply = await handleCommand(cmd, msg, deps);
+        const reply = await handleCommand(cmd, msg, deps, activeStreams);
         await adapter.send(msg.peerId, { text: reply, replyToId: msg.replyToId });
         return;
     }
@@ -125,38 +134,91 @@ async function routeMessage(msg, deps) {
     const key = buildSessionKey(msg.channel, msg.peerId, msg.threadId);
     const sessionId = await deps.sessions.resolveSession(key);
     deps.logger.debug("router: prompting session", { sessionId, channel: msg.channel });
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), deps.timeoutMs);
-    let result;
-    try {
-        result = await deps.client.session.prompt({
-            path: { id: sessionId },
-            body: { parts: [{ type: "text", text: msg.text }] },
+    const pk = peerKey(msg.channel, msg.peerId);
+    activeStreams.set(pk, sessionId);
+    // Start typing indicator
+    if (adapter.sendTyping) {
+        await adapter.sendTyping(msg.peerId).catch(() => { });
+    }
+    const progressEnabled = deps.config.router.progress.enabled;
+    function formatQuestion(request) {
+        const lines = ["❓ The agent has a question:"];
+        for (const q of request.questions) {
+            lines.push("");
+            if (q.header)
+                lines.push(`**${q.header}**`);
+            lines.push(q.question);
+            if (q.options && q.options.length > 0) {
+                for (let i = 0; i < q.options.length; i++) {
+                    const opt = q.options[i];
+                    if (opt) {
+                        lines.push(`  ${i + 1}. ${opt.label}${opt.description ? ` — ${opt.description}` : ""}`);
+                    }
+                }
+            }
+            if (q.multiple)
+                lines.push("(You can pick multiple — separate with commas)");
+        }
+        lines.push("");
+        lines.push("Reply with your answer:");
+        return lines.join("\n");
+    }
+    function waitForUserReply(questionTimeoutMs) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                pendingQuestions.delete(pk);
+                reject(new Error("question_timeout"));
+            }, questionTimeoutMs);
+            pendingQuestions.set(pk, { resolve, timeout: timer });
         });
     }
+    const progress = progressEnabled
+        ? {
+            onToolRunning: (_tool, title) => adapter.send(msg.peerId, {
+                text: `🔧 ${title}...`,
+                replyToId: msg.replyToId,
+            }),
+            onHeartbeat: async () => {
+                if (adapter.sendTyping) {
+                    await adapter.sendTyping(msg.peerId).catch(() => { });
+                }
+                await adapter.send(msg.peerId, { text: "⏳ Still working..." });
+            },
+            onQuestion: async (request) => {
+                const text = formatQuestion(request);
+                await adapter.send(msg.peerId, { text });
+                const userReply = await waitForUserReply(deps.timeoutMs);
+                return request.questions.map(() => [userReply]);
+            },
+            toolThrottleMs: deps.config.router.progress.toolThrottleMs,
+            heartbeatMs: deps.config.router.progress.heartbeatMs,
+        }
+        : undefined;
+    let reply;
+    try {
+        reply = await promptStreaming(deps.client, sessionId, msg.text, deps.timeoutMs, deps.logger, progress);
+    }
     catch (err) {
-        clearTimeout(timer);
-        if (controller.signal.aborted) {
-            deps.logger.warn("router: session prompt timed out", {
-                sessionId,
-                timeoutMs: deps.timeoutMs,
-            });
+        if (err instanceof Error && err.message === "timeout") {
             await adapter.send(msg.peerId, {
                 text: "Request timed out. The agent took too long to respond.",
                 replyToId: msg.replyToId,
             });
             return;
         }
+        if (err instanceof Error && err.message === "aborted") {
+            // Already notified via /cancel reply; nothing more to send
+            return;
+        }
         throw err;
     }
-    clearTimeout(timer);
-    if (!result.data) {
-        deps.logger.error("router: prompt returned no data", { sessionId });
-        await adapter.send(msg.peerId, { text: "Error: no response from agent." });
-        return;
+    finally {
+        activeStreams.delete(pk);
+        pendingQuestions.delete(pk);
+        if (adapter.stopTyping) {
+            await adapter.stopTyping(msg.peerId).catch(() => { });
+        }
     }
-    // Extract text parts from response
-    const reply = extractText(result.data.parts);
     if (!reply) {
         deps.logger.warn("router: empty response from agent", { sessionId });
         await adapter.send(msg.peerId, { text: "(empty response)" });
@@ -165,9 +227,22 @@ async function routeMessage(msg, deps) {
     await adapter.send(msg.peerId, { text: reply, replyToId: msg.replyToId });
 }
 export function createRouter(deps) {
+    // Tracks which sessionId is currently streaming for each channel:peerId pair
+    const activeStreams = new Map();
+    // Tracks pending question resolvers — when agent asks a question, user's next message resolves it
+    const pendingQuestions = new Map();
     async function handler(msg) {
         try {
-            await routeMessage(msg, deps);
+            // Check if this message is a reply to a pending question
+            const pk = peerKey(msg.channel, msg.peerId);
+            const pending = pendingQuestions.get(pk);
+            if (pending) {
+                clearTimeout(pending.timeout);
+                pendingQuestions.delete(pk);
+                pending.resolve(msg.text);
+                return;
+            }
+            await routeMessage(msg, deps, activeStreams, pendingQuestions);
         }
         catch (err) {
             deps.logger.error("router: unhandled error", {

package/dist/channels/slack.js

@@ -80,6 +80,9 @@ export function createSlackAdapter(config, logger) {
                 thread_ts: message.threadId,
             });
         },
+        async sendTyping(_peerId) {
+            // Slack has no general bot typing indicator API
+        },
         status() {
             return state;
         },

package/dist/channels/telegram.js

@@ -72,6 +72,9 @@ export function createTelegramAdapter(config, logger) {
                 reply_parameters: message.replyToId ? { message_id: Number(message.replyToId) } : undefined,
             });
         },
+        async sendTyping(peerId) {
+            await bot.api.sendChatAction(Number(peerId), "typing");
+        },
         status() {
             return state;
         },

package/dist/channels/types.d.ts

@@ -23,5 +23,7 @@ export type ChannelAdapter = {
     start(handler: InboundMessageHandler): Promise<void>;
     stop(): Promise<void>;
     send(peerId: string, message: OutboundMessage): Promise<void>;
+    sendTyping?(peerId: string): Promise<void>;
+    stopTyping?(peerId: string): Promise<void>;
     status(): ChannelStatus;
 };

package/dist/channels/whatsapp.js

@@ -129,6 +129,18 @@ export function createWhatsAppAdapter(config, logger) {
             const jid = `${peerId}@s.whatsapp.net`;
             await sock.sendMessage(jid, { text: message.text });
         },
+        async sendTyping(peerId) {
+            if (!sock)
+                return;
+            const jid = `${peerId}@s.whatsapp.net`;
+            await sock.sendPresenceUpdate("composing", jid);
+        },
+        async stopTyping(peerId) {
+            if (!sock)
+                return;
+            const jid = `${peerId}@s.whatsapp.net`;
+            await sock.sendPresenceUpdate("paused", jid);
+        },
         status() {
             return state;
         },

package/dist/cli.js

@@ -1,6 +1,24 @@
 #!/usr/bin/env node
 import { main } from "./index.js";
-main().catch((err) => {
-    console.error("Fatal:", err);
-    process.exit(1);
-});
+const args = process.argv.slice(2);
+if (args.includes("--init")) {
+    const { runOnboardingWizard } = await import("./wizard/onboarding.js");
+    const { createClackPrompter } = await import("./wizard/clack-prompter.js");
+    const { WizardCancelledError } = await import("./wizard/prompts.js");
+    const prompter = createClackPrompter();
+    try {
+        await runOnboardingWizard(prompter);
+    }
+    catch (err) {
+        if (err instanceof WizardCancelledError) {
+            process.exit(1);
+        }
+        throw err;
+    }
+}
+else {
+    main().catch((err) => {
+        console.error("Fatal:", err);
+        process.exit(1);
+    });
+}

package/dist/config/schema.d.ts

@@ -310,10 +310,33 @@ export declare const configSchema: z.ZodObject<{
     }>>;
     router: z.ZodDefault<z.ZodObject<{
         timeoutMs: z.ZodDefault<z.ZodNumber>;
+        progress: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            toolThrottleMs: z.ZodDefault<z.ZodNumber>;
+            heartbeatMs: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            toolThrottleMs: number;
+            heartbeatMs: number;
+        }, {
+            enabled?: boolean | undefined;
+            toolThrottleMs?: number | undefined;
+            heartbeatMs?: number | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         timeoutMs: number;
+        progress: {
+            enabled: boolean;
+            toolThrottleMs: number;
+            heartbeatMs: number;
+        };
     }, {
         timeoutMs?: number | undefined;
+        progress?: {
+            enabled?: boolean | undefined;
+            toolThrottleMs?: number | undefined;
+            heartbeatMs?: number | undefined;
+        } | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     opencode: {
@@ -375,6 +398,11 @@ export declare const configSchema: z.ZodObject<{
     };
     router: {
         timeoutMs: number;
+        progress: {
+            enabled: boolean;
+            toolThrottleMs: number;
+            heartbeatMs: number;
+        };
     };
     cron?: {
         enabled: boolean;
@@ -478,5 +506,10 @@ export declare const configSchema: z.ZodObject<{
     } | undefined;
     router?: {
         timeoutMs?: number | undefined;
+        progress?: {
+            enabled?: boolean | undefined;
+            toolThrottleMs?: number | undefined;
+            heartbeatMs?: number | undefined;
+        } | undefined;
     } | undefined;
 }>;

package/dist/config/schema.js

@@ -103,6 +103,13 @@ export const configSchema = z.object({
     router: z
         .object({
         timeoutMs: z.number().int().min(1000).default(300_000),
+        progress: z
+            .object({
+            enabled: z.boolean().default(true),
+            toolThrottleMs: z.number().int().min(1000).default(5_000),
+            heartbeatMs: z.number().int().min(10_000).default(60_000),
+        })
+            .default({}),
     })
         .default({}),
 });

package/dist/cron/scheduler.d.ts

@@ -1,4 +1,4 @@
-import type { OpencodeClient } from "@opencode-ai/sdk";
+import type { OpencodeClient } from "@opencode-ai/sdk/v2";
 import type { CronConfig } from "../config/types.js";
 import type { OutboxWriter } from "../outbox/writer.js";
 import type { Logger } from "../utils/logger.js";

package/dist/cron/scheduler.js

@@ -1,10 +1,5 @@
 import cron from "node-cron";
-function extractText(parts) {
-    return parts
-        .filter((p) => p.type === "text" && typeof p.text === "string")
-        .map((p) => p.text)
-        .join("\n\n");
-}
+import { promptStreaming } from "../sessions/prompt.js";
 export function createCronScheduler(deps) {
     const jobs = new Map();
     const running = new Set();
@@ -18,39 +13,24 @@ export function createCronScheduler(deps) {
         deps.logger.info(`cron: firing job "${job.id}"`, { schedule: job.schedule });
         try {
             const session = await deps.client.session.create({
-                body: { title },
+                title,
             });
             if (!session.data)
                 throw new Error("session.create returned no data");
             const sessionId = session.data.id;
             deps.logger.debug(`cron: job "${job.id}" session created`, { sessionId });
-            // session.prompt() is synchronous — blocks until the agent finishes.
-            // Wrap with AbortSignal timeout for safety.
             const timeout = job.timeoutMs ?? deps.config.defaultTimeoutMs;
-            const controller = new AbortController();
-            const timer = setTimeout(() => controller.abort(), timeout);
-            let result;
+            let text;
             try {
-                result = await deps.client.session.prompt({
-                    path: { id: sessionId },
-                    body: { parts: [{ type: "text", text: job.prompt }] },
-                });
+                text = await promptStreaming(deps.client, sessionId, job.prompt, timeout, deps.logger);
             }
             catch (err) {
-                if (controller.signal.aborted) {
+                if (err instanceof Error && err.message === "timeout") {
                     deps.logger.warn(`cron: job "${job.id}" timed out after ${timeout}ms`);
                     return;
                 }
                 throw err;
             }
-            finally {
-                clearTimeout(timer);
-            }
-            if (!result.data) {
-                deps.logger.warn(`cron: job "${job.id}" returned no data`);
-                return;
-            }
-            const text = extractText(result.data.parts);
             deps.logger.info(`cron: job "${job.id}" completed`, {
                 sessionId,
                 responseLength: text.length,

package/dist/index.js

@@ -1,6 +1,6 @@
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { createOpencode } from "@opencode-ai/sdk";
+import { createOpencode } from "@opencode-ai/sdk/v2";
 import { createRouter } from "./channels/router.js";
 import { createSlackAdapter } from "./channels/slack.js";
 import { createTelegramAdapter } from "./channels/telegram.js";

package/dist/sessions/manager.d.ts

@@ -1,4 +1,4 @@
-import type { OpencodeClient } from "@opencode-ai/sdk";
+import type { OpencodeClient } from "@opencode-ai/sdk/v2";
 import type { SessionsConfig } from "../config/types.js";
 import type { Logger } from "../utils/logger.js";
 export type SessionInfo = {

package/dist/sessions/manager.js

@@ -14,7 +14,7 @@ export function createSessionManager(client, config, map, logger) {
         if (existing)
             return existing;
         const session = await client.session.create({
-            body: { title: title ?? key },
+            title: title ?? key,
         });
         if (!session.data)
             throw new Error("session.create returned no data");
@@ -30,7 +30,7 @@ export function createSessionManager(client, config, map, logger) {
     }
     async function newSession(key, title) {
         const session = await client.session.create({
-            body: { title: title ?? `New session ${new Date().toISOString()}` },
+            title: title ?? `New session ${new Date().toISOString()}`,
         });
         if (!session.data)
             throw new Error("session.create returned no data");

package/dist/sessions/prompt.d.ts

@@ -0,0 +1,13 @@
+import type { OpencodeClient, QuestionRequest } from "@opencode-ai/sdk/v2";
+import type { Logger } from "../utils/logger.js";
+export type ToolProgressCallback = (tool: string, title: string) => Promise<void>;
+export type HeartbeatCallback = () => Promise<void>;
+export type QuestionCallback = (question: QuestionRequest) => Promise<Array<Array<string>>>;
+export type ProgressOptions = {
+    onToolRunning?: ToolProgressCallback;
+    onHeartbeat?: HeartbeatCallback;
+    onQuestion?: QuestionCallback;
+    toolThrottleMs?: number;
+    heartbeatMs?: number;
+};
+export declare function promptStreaming(client: OpencodeClient, sessionId: string, promptText: string, timeoutMs: number, logger: Logger, progress?: ProgressOptions): Promise<string>;

package/dist/sessions/prompt.js

@@ -0,0 +1,118 @@
+export async function promptStreaming(client, sessionId, promptText, timeoutMs, logger, progress) {
+    const { stream } = await client.event.subscribe();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const textParts = new Map();
+    const notifiedTools = new Set();
+    let lastToolNotifyTime = 0;
+    let lastActivityTime = Date.now();
+    let heartbeatTimer;
+    const toolThrottleMs = progress?.toolThrottleMs ?? 5_000;
+    const heartbeatMs = progress?.heartbeatMs ?? 60_000;
+    if (progress?.onHeartbeat && heartbeatMs > 0) {
+        const onHeartbeat = progress.onHeartbeat;
+        heartbeatTimer = setInterval(() => {
+            const elapsed = Date.now() - lastActivityTime;
+            if (elapsed >= heartbeatMs) {
+                onHeartbeat().catch(() => { });
+                lastActivityTime = Date.now();
+            }
+        }, heartbeatMs);
+    }
+    function touchActivity() {
+        lastActivityTime = Date.now();
+    }
+    try {
+        await client.session.promptAsync({
+            sessionID: sessionId,
+            parts: [{ type: "text", text: promptText }],
+        });
+        for await (const raw of stream) {
+            if (controller.signal.aborted) {
+                throw new Error("timeout");
+            }
+            const event = raw;
+            if (event.type === "message.part.delta") {
+                const { sessionID, partID, delta } = event.properties;
+                if (sessionID !== sessionId)
+                    continue;
+                const prev = textParts.get(partID) ?? "";
+                textParts.set(partID, prev + delta);
+                continue;
+            }
+            if (event.type === "message.part.updated") {
+                const { part } = event.properties;
+                if (part.sessionID !== sessionId)
+                    continue;
+                if (part.type === "text" && part.text) {
+                    textParts.set(part.id, part.text);
+                }
+                if (part.type === "tool" && part.state.status === "running" && progress?.onToolRunning) {
+                    const now = Date.now();
+                    if (!notifiedTools.has(part.callID) && now - lastToolNotifyTime >= toolThrottleMs) {
+                        notifiedTools.add(part.callID);
+                        lastToolNotifyTime = now;
+                        const title = "title" in part.state && part.state.title ? part.state.title : part.tool;
+                        await progress.onToolRunning(part.tool, title).catch(() => { });
+                        touchActivity();
+                    }
+                }
+                continue;
+            }
+            if (event.type === "question.asked") {
+                const request = event.properties;
+                if (request.sessionID !== sessionId)
+                    continue;
+                if (progress?.onQuestion) {
+                    try {
+                        const answers = await progress.onQuestion(request);
+                        await client.question.reply({
+                            requestID: request.id,
+                            answers,
+                        });
+                        touchActivity();
+                    }
+                    catch {
+                        await client.question.reject({ requestID: request.id });
+                    }
+                }
+                else {
+                    await client.question.reject({ requestID: request.id });
+                }
+                continue;
+            }
+            if (event.type === "session.error") {
+                const { sessionID, error } = event.properties;
+                if (sessionID && sessionID !== sessionId)
+                    continue;
+                if (error && "name" in error && error.name === "MessageAbortedError") {
+                    throw new Error("aborted");
+                }
+                const msg = error && "data" in error && typeof error.data.message === "string"
+                    ? error.data.message
+                    : "unknown session error";
+                throw new Error(msg);
+            }
+            if (event.type === "session.idle") {
+                if (event.properties.sessionID !== sessionId)
+                    continue;
+                break;
+            }
+        }
+    }
+    catch (err) {
+        if (controller.signal.aborted || (err instanceof Error && err.message === "timeout")) {
+            logger.warn("prompt: session timed out", { sessionId, timeoutMs });
+            throw new Error("timeout");
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timer);
+        if (heartbeatTimer)
+            clearInterval(heartbeatTimer);
+        await stream.return(undefined);
+    }
+    const parts = [...textParts.values()];
+    return parts.join("");
+}

package/dist/wizard/clack-prompter.d.ts

@@ -0,0 +1,2 @@
+import type { WizardPrompter } from "./prompts.js";
+export declare function createClackPrompter(): WizardPrompter;

package/dist/wizard/clack-prompter.js

@@ -0,0 +1,53 @@
+import { cancel, confirm, intro, isCancel, note, outro, select, text } from "@clack/prompts";
+import { WizardCancelledError } from "./prompts.js";
+function guardCancel(value) {
+    if (isCancel(value)) {
+        cancel("Setup cancelled.");
+        throw new WizardCancelledError();
+    }
+    return value;
+}
+export function createClackPrompter() {
+    return {
+        async intro(title) {
+            intro(title);
+        },
+        async outro(message) {
+            outro(message);
+        },
+        async note(message, title) {
+            note(message, title);
+        },
+        async select(params) {
+            const result = await select({
+                message: params.message,
+                options: params.options,
+                initialValue: params.initialValue,
+            });
+            return guardCancel(result);
+        },
+        async text(params) {
+            const result = await text({
+                message: params.message,
+                initialValue: params.initialValue,
+                placeholder: params.placeholder,
+                validate: params.validate
+                    ? (value) => {
+                        const fn = params.validate;
+                        if (!fn)
+                            return undefined;
+                        return fn(value ?? "");
+                    }
+                    : undefined,
+            });
+            return guardCancel(result);
+        },
+        async confirm(params) {
+            const result = await confirm({
+                message: params.message,
+                initialValue: params.initialValue,
+            });
+            return guardCancel(result);
+        },
+    };
+}

package/dist/wizard/onboarding.d.ts

@@ -0,0 +1,2 @@
+import type { WizardPrompter } from "./prompts.js";
+export declare function runOnboardingWizard(p: WizardPrompter): Promise<void>;

package/dist/wizard/onboarding.js

@@ -0,0 +1,209 @@
+import { access, writeFile } from "node:fs/promises";
+const ALL_CAPS_RE = /^[A-Z][A-Z0-9_]*$/;
+function resolveTokenValue(input) {
+    const trimmed = input.trim();
+    if (trimmed.startsWith("${") && trimmed.endsWith("}"))
+        return trimmed;
+    if (trimmed.startsWith("$"))
+        return `\${${trimmed.slice(1)}}`;
+    if (ALL_CAPS_RE.test(trimmed))
+        return `\${${trimmed}}`;
+    return trimmed;
+}
+function splitAllowlist(raw) {
+    return raw
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+}
+async function collectTelegramConfig(p) {
+    const rawToken = await p.text({
+        message: "Telegram bot token (paste value or env var name like TELEGRAM_BOT_TOKEN):",
+        placeholder: "TELEGRAM_BOT_TOKEN",
+        validate: (v) => (v.trim().length === 0 ? "Required" : undefined),
+    });
+    const botToken = resolveTokenValue(rawToken);
+    const rawAllowlist = await p.text({
+        message: "Allowed Telegram usernames (comma-separated, leave blank for none):",
+        placeholder: "alice,bob",
+    });
+    return {
+        enabled: true,
+        botToken,
+        allowlist: splitAllowlist(rawAllowlist),
+        mode: "polling",
+        rejectionBehavior: "ignore",
+    };
+}
+async function collectSlackConfig(p) {
+    const rawBotToken = await p.text({
+        message: "Slack bot token (xoxb-... or env var name like SLACK_BOT_TOKEN):",
+        placeholder: "SLACK_BOT_TOKEN",
+        validate: (v) => (v.trim().length === 0 ? "Required" : undefined),
+    });
+    const botToken = resolveTokenValue(rawBotToken);
+    const rawAppToken = await p.text({
+        message: "Slack app token (xapp-... or env var name like SLACK_APP_TOKEN):",
+        placeholder: "SLACK_APP_TOKEN",
+        validate: (v) => (v.trim().length === 0 ? "Required" : undefined),
+    });
+    const appToken = resolveTokenValue(rawAppToken);
+    return {
+        enabled: true,
+        botToken,
+        appToken,
+        mode: "socket",
+        rejectionBehavior: "ignore",
+    };
+}
+async function collectWhatsAppConfig(p) {
+    const rawAllowlist = await p.text({
+        message: "Allowed phone numbers (comma-separated with country code, e.g. 5511999887766):",
+        placeholder: "5511999887766,441234567890",
+        validate: (v) => (v.trim().length === 0 ? "Required" : undefined),
+    });
+    return {
+        enabled: true,
+        allowlist: splitAllowlist(rawAllowlist),
+        authDir: "./data/whatsapp/auth",
+        debounceMs: 1000,
+        rejectionBehavior: "ignore",
+    };
+}
+async function collectChannels(p) {
+    const channels = {};
+    const configured = new Set();
+    const channelOptions = [
+        { value: "telegram", label: "Telegram", hint: "requires bot token" },
+        { value: "slack", label: "Slack", hint: "requires bot + app token" },
+        { value: "whatsapp", label: "WhatsApp", hint: "scan QR on first run" },
+        { value: "skip", label: "Skip — no channels now" },
+    ];
+    let configureMore = true;
+    while (configureMore) {
+        const available = channelOptions.filter((o) => o.value === "skip" || !configured.has(o.value));
+        const choice = await p.select({
+            message: "Which channel would you like to configure?",
+            options: available,
+        });
+        if (choice === "skip")
+            break;
+        const channelId = choice;
+        if (channelId === "telegram") {
+            channels.telegram = await collectTelegramConfig(p);
+            configured.add("telegram");
+        }
+        else if (channelId === "slack") {
+            channels.slack = await collectSlackConfig(p);
+            configured.add("slack");
+        }
+        else if (channelId === "whatsapp") {
+            channels.whatsapp = await collectWhatsAppConfig(p);
+            configured.add("whatsapp");
+        }
+        const allChannels = ["telegram", "slack", "whatsapp"];
+        const remaining = allChannels.filter((c) => !configured.has(c));
+        if (remaining.length === 0)
+            break;
+        configureMore = await p.confirm({
+            message: "Configure another channel?",
+            initialValue: false,
+        });
+    }
+    return channels;
+}
+async function collectMemoryConfig(p) {
+    const backend = await p.select({
+        message: "Memory backend:",
+        options: [
+            { value: "txt", label: "Text files (simple, zero deps)" },
+            { value: "openviking", label: "OpenViking (semantic search)" },
+        ],
+        initialValue: "txt",
+    });
+    if (backend === "openviking") {
+        const url = await p.text({
+            message: "OpenViking URL:",
+            initialValue: "http://localhost:8100",
+            validate: (v) => {
+                try {
+                    new URL(v);
+                    return undefined;
+                }
+                catch {
+                    return "Must be a valid URL";
+                }
+            },
+        });
+        const fallback = await p.confirm({
+            message: "Fall back to text files if OpenViking is unreachable?",
+            initialValue: true,
+        });
+        return { backend: "openviking", openviking: { url, fallback } };
+    }
+    return { backend: "txt" };
+}
+export async function runOnboardingWizard(p) {
+    const configPath = "./opencode-claw.json";
+    let existingConfigFound = false;
+    try {
+        await access(configPath);
+        existingConfigFound = true;
+    }
+    catch {
+        // file doesn't exist — proceed
+    }
+    if (existingConfigFound) {
+        const overwrite = await p.confirm({
+            message: "opencode-claw.json already exists. Overwrite it?",
+            initialValue: false,
+        });
+        if (!overwrite) {
+            await p.outro("Setup cancelled. Existing config unchanged.");
+            return;
+        }
+    }
+    await p.intro("opencode-claw setup");
+    const channels = await collectChannels(p);
+    const memory = await collectMemoryConfig(p);
+    const portRaw = await p.text({
+        message: "OpenCode server port (0 = random):",
+        initialValue: "0",
+        validate: (v) => {
+            const n = Number(v);
+            if (!Number.isInteger(n) || n < 0 || n > 65535)
+                return "Must be an integer 0–65535";
+            return undefined;
+        },
+    });
+    const port = Number(portRaw);
+    const enableCron = await p.confirm({
+        message: "Enable cron job scheduling?",
+        initialValue: false,
+    });
+    if (enableCron) {
+        await p.note("Add jobs to the config file manually after setup.\nSee opencode-claw.example.json for the cron job schema.", "Cron jobs");
+    }
+    const channelSummary = Object.keys(channels).length === 0
+        ? "  No channels configured"
+        : Object.keys(channels)
+            .map((c) => `  - ${c}`)
+            .join("\n");
+    const memorySummary = memory.backend === "openviking"
+        ? `  openviking (${memory.openviking.url})`
+        : "  txt (./data/memory)";
+    await p.note([
+        `Channels:\n${channelSummary}`,
+        `Memory: ${memorySummary}`,
+        `OpenCode port: ${port}`,
+        `Cron: ${enableCron ? "enabled" : "disabled"}`,
+    ].join("\n"), "Config summary");
+    const config = {
+        opencode: { port },
+        memory,
+        channels,
+        ...(enableCron ? { cron: { enabled: true, defaultTimeoutMs: 300000, jobs: [] } } : {}),
+    };
+    await writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+    await p.outro("Config written to opencode-claw.json. Run 'npx opencode-claw' to start.");
+}

package/dist/wizard/prompts.d.ts

@@ -0,0 +1,31 @@
+export type WizardSelectOption<T = string> = {
+    value: T;
+    label: string;
+    hint?: string;
+};
+export type WizardSelectParams<T = string> = {
+    message: string;
+    options: Array<WizardSelectOption<T>>;
+    initialValue?: T;
+};
+export type WizardTextParams = {
+    message: string;
+    initialValue?: string;
+    placeholder?: string;
+    validate?: (value: string) => string | undefined;
+};
+export type WizardConfirmParams = {
+    message: string;
+    initialValue?: boolean;
+};
+export type WizardPrompter = {
+    intro: (title: string) => Promise<void>;
+    outro: (message: string) => Promise<void>;
+    note: (message: string, title?: string) => Promise<void>;
+    select: <T>(params: WizardSelectParams<T>) => Promise<T>;
+    text: (params: WizardTextParams) => Promise<string>;
+    confirm: (params: WizardConfirmParams) => Promise<boolean>;
+};
+export declare class WizardCancelledError extends Error {
+    constructor();
+}

package/dist/wizard/prompts.js

@@ -0,0 +1,6 @@
+export class WizardCancelledError extends Error {
+    constructor() {
+        super("Wizard cancelled by user");
+        this.name = "WizardCancelledError";
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-claw",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Wrap OpenCode with persistent memory, messaging channels, and cron jobs",
   "license": "MIT",
   "type": "module",
@@ -47,7 +47,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "start": "bun run src/index.ts",
+    "start": "bun run src/cli.ts",
     "build": "tsc --build",
     "prepublishOnly": "npm run build",
     "typecheck": "bun x tsc --noEmit",
@@ -58,12 +58,13 @@
     "test:e2e": "bun test test/"
   },
   "dependencies": {
-    "@opencode-ai/sdk": "^1.2.10",
-    "@opencode-ai/plugin": "^1.2.10",
-    "grammy": "^1.35.0",
+    "@clack/prompts": "^1.0.1",
     "@grammyjs/runner": "^2.0.3",
+    "@opencode-ai/plugin": "^1.2.10",
+    "@opencode-ai/sdk": "^1.2.10",
     "@slack/bolt": "^4.3.0",
     "@whiskeysockets/baileys": "^6.7.16",
+    "grammy": "^1.35.0",
     "node-cron": "^3.0.3",
     "zod": "^3.24.0"
   },