@rubytech/taskmaster 1.9.5 → 1.9.7

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.9.5",
-  "commit": "521c1bca1da1357a98d5afc5f71aafcf2a5831b8",
-  "builtAt": "2026-02-28T15:36:00.493Z"
+  "version": "1.9.7",
+  "commit": "728a31bb44d34f67c214b4a7fbe191f1c72843f2",
+  "builtAt": "2026-02-28T16:34:23.647Z"
 }

package/dist/gateway/server-methods/tailscale.js

@@ -122,6 +122,29 @@ export const tailscaleHandlers = {
                 message: typeof errObj.message === "string" ? errObj.message : "",
             };
         };
+        const needsSudo = (output) => {
+            const lower = output.toLowerCase();
+            return (lower.includes("access denied") ||
+                lower.includes("permission denied") ||
+                lower.includes("use 'sudo tailscale") ||
+                lower.includes("requires root"));
+        };
+        // Run `tailscale up` (with optional extra args) and capture output.
+        // If the command fails with a permission error, retries with `sudo -n`.
+        // `tailscale up` blocks until auth completes, so timeouts are expected —
+        // the auth URL appears in stdout/stderr before the timeout kills it.
+        const runTailscaleUp = async (binary, extraArgs = []) => {
+            const args = ["up", ...extraArgs];
+            const execOpts = { timeoutMs: 60_000, maxBuffer: 100_000 };
+            const result = await runExec(binary, args, execOpts).catch((err) => captureExecOutput(err));
+            const output = `${result.stdout}\n${result.stderr}`;
+            if (!needsSudo(output))
+                return output;
+            // Permission denied — retry with sudo -n (non-interactive)
+            context.logGateway.info(`tailscale.enable: permission denied, retrying with sudo: ${args.join(" ")}`);
+            const sudoResult = await runExec("sudo", ["-n", binary, ...args], execOpts).catch((err) => captureExecOutput(err));
+            return `${sudoResult.stdout}\n${sudoResult.stderr}`;
+        };
         try {
             const binary = await findTailscaleBinary();
             if (!binary) {
@@ -149,20 +172,7 @@ export const tailscaleHandlers = {
                 // Other status errors (e.g. NeedsLogin) are fine — continue to `tailscale up`
             }
             // ── Attempt 1: `tailscale up` ──
-            // On a headless device this prints:
-            // "To authenticate, visit:\n\n\thttps://login.tailscale.com/a/..."
-            // The command blocks until auth completes, so we run it with a
-            // timeout and parse the auth URL from the output. The URL appears
-            // within seconds; the timeout just kills the blocking wait.
-            const child = await runExec(binary, ["up"], {
-                timeoutMs: 60_000,
-                maxBuffer: 100_000,
-            }).catch((err) => {
-                // `tailscale up` exits non-zero while waiting for auth but still
-                // prints the URL to stdout/stderr before the timeout kills it.
-                return captureExecOutput(err);
-            });
-            const combined = `${child.stdout}\n${child.stderr}`;
+            const combined = await runTailscaleUp(binary);
             const authUrl = extractAuthUrl(combined);
             if (authUrl) {
                 respond(true, { authUrl });
@@ -184,11 +194,7 @@ export const tailscaleHandlers = {
             // state where plain `tailscale up` doesn't produce a new auth URL.
             // --force-reauth forces a fresh login flow that always emits a URL.
             context.logGateway.info("tailscale.enable: no auth URL from initial attempt, retrying with --force-reauth");
-            const retry = await runExec(binary, ["up", "--force-reauth"], {
-                timeoutMs: 60_000,
-                maxBuffer: 100_000,
-            }).catch((err) => captureExecOutput(err));
-            const retryCombined = `${retry.stdout}\n${retry.stderr}`;
+            const retryCombined = await runTailscaleUp(binary, ["--force-reauth"]);
             const retryUrl = extractAuthUrl(retryCombined);
             if (retryUrl) {
                 respond(true, { authUrl: retryUrl });

package/dist/suggestions/broadcast.js

@@ -0,0 +1,100 @@
+/**
+ * Fire-and-forget suggestion generation + broadcast.
+ *
+ * Called after broadcastChatFinal (follow-up mode) and after
+ * chat.history returns empty messages (session-start mode).
+ */
+import { resolveAgentWorkspaceDir, resolveSessionAgentId } from "../agents/agent-scope.js";
+import { resolveIdentityName } from "../agents/identity.js";
+import { loadConfig } from "../config/config.js";
+import { loadSessionEntry, readSessionMessages } from "../gateway/session-utils.js";
+import { generateSuggestions } from "./generator.js";
+/** Default model for suggestion generation. */
+const SUGGESTION_MODEL = "claude-haiku-4-5-20251001";
+/** Number of recent messages to include as context for suggestion generation. */
+const RECENT_MESSAGES_LIMIT = 10;
+/** Extract text from a session message (handles both string and structured content). */
+function extractMessageText(msg) {
+    if (!msg || typeof msg !== "object")
+        return "";
+    const m = msg;
+    if (typeof m.content === "string")
+        return m.content;
+    if (Array.isArray(m.content)) {
+        return m.content
+            .filter((c) => c.type === "text" && typeof c.text === "string")
+            .map((c) => c.text)
+            .join(" ");
+    }
+    return "";
+}
+/**
+ * Load recent conversation messages for context. Returns a formatted string
+ * with the last N messages (user + assistant turns).
+ */
+function loadRecentMessages(sessionKey) {
+    try {
+        const { storePath, entry } = loadSessionEntry(sessionKey);
+        if (!entry?.sessionId || !storePath)
+            return "";
+        const messages = readSessionMessages(entry.sessionId, storePath, entry.sessionFile);
+        if (messages.length === 0)
+            return "";
+        // Take the last N messages
+        const recent = messages.slice(-RECENT_MESSAGES_LIMIT);
+        return recent
+            .map((msg) => {
+            const m = msg;
+            const role = m.role === "assistant" ? "Assistant" : "User";
+            const text = extractMessageText(msg);
+            if (!text)
+                return null;
+            // Truncate long messages
+            const truncated = text.length > 200 ? `${text.slice(0, 200)}...` : text;
+            return `${role}: ${truncated}`;
+        })
+            .filter(Boolean)
+            .join("\n");
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Generate suggestions and broadcast them. Fire-and-forget — errors are logged, never thrown.
+ */
+export function fireSuggestion(params) {
+    const { sessionKey, broadcast, cfg, lastUserMessage, lastAssistantReply } = params;
+    const config = cfg ?? loadConfig();
+    const agentId = resolveSessionAgentId({ sessionKey, config });
+    const agentDir = resolveAgentWorkspaceDir(config, agentId);
+    const assistantName = resolveIdentityName(config, agentId);
+    // Load recent conversation for better context
+    const recentMessages = loadRecentMessages(sessionKey);
+    if (!recentMessages) {
+        console.warn(`[suggestions] no recent messages found for sessionKey=${sessionKey}`);
+    }
+    void generateSuggestions({
+        model: SUGGESTION_MODEL,
+        lastUserMessage,
+        lastAssistantReply,
+        recentMessages,
+        assistantName,
+        cfg: config,
+        agentDir,
+    })
+        .then((result) => {
+        if (result.ok) {
+            broadcast("suggestions", {
+                sessionKey,
+                suggestions: result.texts,
+            });
+        }
+        else {
+            console.warn(`[suggestions] generation failed: ${result.error.message}`);
+        }
+    })
+        .catch((err) => {
+        console.warn(`[suggestions] unexpected error: ${err instanceof Error ? err.message : String(err)}`);
+    });
+}

package/dist/suggestions/generator.js

@@ -0,0 +1,165 @@
+/**
+ * Suggestion chip generation.
+ *
+ * Two modes:
+ * - Session start: picks from curated opener pairs (no AI call)
+ * - Follow-up: uses Haiku to generate two contextual quick-replies (affirmative + negative)
+ */
+import path from "node:path";
+import { complete } from "@mariozechner/pi-ai";
+import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+import { getApiKeyForModel, requireApiKey } from "../agents/model-auth.js";
+import { ensureTaskmasterModelsJson } from "../agents/models-config.js";
+const FOLLOW_UP_SYSTEM_PROMPT = `Output ONLY a JSON array with exactly two strings. No explanation, no markdown, no labels.`;
+/**
+ * Curated session-start opener pairs. Picked randomly.
+ * Each pair has an affirmative and an alternative option.
+ */
+const SESSION_START_OPENER_PAIRS = [
+    ["What's on the schedule today?", "Give me a quick briefing"],
+    ["Any messages I should catch up on?", "What needs my attention?"],
+    ["Help me plan my day", "Anything urgent right now?"],
+    ["What's new since yesterday?", "Show me my to-do list"],
+    ["Any updates I should know about?", "Let's get started"],
+];
+/**
+ * Pick a random session-start opener pair. No AI call needed.
+ */
+export function pickSessionStartSuggestions() {
+    const pair = SESSION_START_OPENER_PAIRS[Math.floor(Math.random() * SESSION_START_OPENER_PAIRS.length)];
+    return { ok: true, texts: [pair[0], pair[1]] };
+}
+/** Strip surrounding quotes from a string. */
+function stripQuotes(s) {
+    let text = s.trim();
+    if ((text.startsWith('"') && text.endsWith('"')) ||
+        (text.startsWith("'") && text.endsWith("'"))) {
+        text = text.slice(1, -1).trim();
+    }
+    return text;
+}
+/**
+ * Generate two follow-up suggestions using Haiku. Requires conversation context.
+ */
+export async function generateFollowUpSuggestions(params) {
+    const { model: modelId, lastUserMessage, lastAssistantReply, recentMessages, assistantName, timeoutMs = 4000, cfg, agentDir, } = params;
+    if (!lastAssistantReply) {
+        return { ok: false, error: new Error("Follow-up requires lastAssistantReply") };
+    }
+    try {
+        await ensureTaskmasterModelsJson(cfg, agentDir);
+        const authStorage = agentDir
+            ? new AuthStorage(path.join(agentDir, "auth.json"))
+            : new AuthStorage();
+        const modelRegistry = agentDir
+            ? new ModelRegistry(authStorage, path.join(agentDir, "models.json"))
+            : new ModelRegistry(authStorage);
+        const model = modelRegistry.find("anthropic", modelId);
+        if (!model) {
+            return { ok: false, error: new Error(`Suggestion model not found: anthropic/${modelId}`) };
+        }
+        const apiKeyInfo = await getApiKeyForModel({ model, cfg, agentDir });
+        const apiKey = requireApiKey(apiKeyInfo, model.provider);
+        authStorage.setRuntimeApiKey(model.provider, apiKey);
+        // Build prompt from conversation history when available, fall back to last exchange
+        let prompt;
+        // Build the conversation context — prefer full history, fall back to last exchange
+        const name = assistantName || "Assistant";
+        let conversationContext;
+        if (recentMessages) {
+            conversationContext = recentMessages;
+        }
+        else {
+            const truncatedReply = lastAssistantReply.length > 300
+                ? `${lastAssistantReply.slice(0, 300)}...`
+                : lastAssistantReply;
+            const truncatedUser = lastUserMessage && lastUserMessage.length > 200
+                ? `${lastUserMessage.slice(0, 200)}...`
+                : (lastUserMessage ?? "");
+            conversationContext = `User: ${truncatedUser}\n${name}: ${truncatedReply}`;
+        }
+        prompt = `${conversationContext}\n\nPredict the next message from the user. Give me two options that oppose each other if possible.`;
+        const context = {
+            systemPrompt: FOLLOW_UP_SYSTEM_PROMPT,
+            messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
+        };
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => reject(new Error("Suggestion generation timeout")), timeoutMs);
+        });
+        const message = (await Promise.race([
+            complete(model, context, {
+                apiKey,
+                maxTokens: 100,
+                temperature: 0.8,
+            }),
+            timeoutPromise,
+        ]));
+        const content = message.content?.[0];
+        if (!content || content.type !== "text" || !content.text) {
+            return { ok: false, error: new Error("Empty suggestion response") };
+        }
+        // Strip markdown code fences (```json ... ```) before parsing
+        let raw = content.text.trim();
+        raw = raw
+            .replace(/^```(?:json)?\s*\n?/i, "")
+            .replace(/\n?```\s*$/, "")
+            .trim();
+        // Parse JSON array response
+        try {
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed) && parsed.length >= 2) {
+                const texts = parsed.slice(0, 2).map((s) => stripQuotes(String(s)));
+                if (texts.every((t) => t.length > 0)) {
+                    return { ok: true, texts };
+                }
+            }
+        }
+        catch {
+            // If JSON parsing fails, try to extract two lines
+            const lines = raw
+                .split("\n")
+                .map((l) => stripQuotes(l))
+                .filter((l) => l.length > 0);
+            if (lines.length >= 2) {
+                return { ok: true, texts: [lines[0], lines[1]] };
+            }
+            // Fall back to single suggestion
+            if (lines.length === 1) {
+                return { ok: true, texts: [lines[0]] };
+            }
+        }
+        return { ok: false, error: new Error("Could not parse suggestion pair from response") };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        return { ok: false, error };
+    }
+}
+/**
+ * Generate suggestions. Delegates to the appropriate strategy based on context.
+ */
+export async function generateSuggestions(params) {
+    if (params.lastAssistantReply) {
+        return generateFollowUpSuggestions(params);
+    }
+    return pickSessionStartSuggestions();
+}
+// --- Legacy single-suggestion API (preserved for backwards compatibility) ---
+/**
+ * Pick a random session-start opener. No AI call needed.
+ */
+export function pickSessionStartSuggestion() {
+    const result = pickSessionStartSuggestions();
+    if (!result.ok)
+        return result;
+    return { ok: true, text: result.texts[0] };
+}
+/**
+ * Generate a suggestion. Delegates to the appropriate strategy based on context.
+ */
+export async function generateSuggestion(params) {
+    const result = await generateSuggestions(params);
+    if (!result.ok)
+        return result;
+    return { ok: true, text: result.texts[0] };
+}

package/dist/suggestions/greeting.js

@@ -0,0 +1,88 @@
+/**
+ * Generate a proactive greeting for the public chat widget.
+ *
+ * Uses Haiku to create a short, friendly first message based on the agent's
+ * identity (name + SOUL.md persona). If no model/key is available, falls back
+ * to a generic greeting.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { complete } from "@mariozechner/pi-ai";
+import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+import { resolveAgentWorkspaceDir } from "../agents/agent-scope.js";
+import { resolveIdentityName } from "../agents/identity.js";
+import { DEFAULT_SOUL_FILENAME } from "../agents/workspace.js";
+import { getApiKeyForModel, requireApiKey } from "../agents/model-auth.js";
+import { ensureTaskmasterModelsJson } from "../agents/models-config.js";
+const GREETING_MODEL = "claude-haiku-4-5-20251001";
+const SYSTEM_PROMPT = `You write a single short, friendly greeting that an AI assistant would use to start a conversation with a website visitor. Output ONLY the greeting text — no quotes, no prefix, no explanation.
+
+Rules:
+1. Keep it warm, approachable, and natural (10-25 words)
+2. Reflect the assistant's personality and role if context is provided
+3. Invite the visitor to ask a question or start a conversation
+4. Never mention being an AI or chatbot — just be helpful
+5. Do not use emojis`;
+export async function generateGreeting(params) {
+    const { cfg, agentId } = params;
+    const agentDir = resolveAgentWorkspaceDir(cfg, agentId);
+    const name = resolveIdentityName(cfg, agentId) ?? "Assistant";
+    // Read SOUL.md for persona context (if present)
+    let soulContext = "";
+    try {
+        const soulPath = path.join(agentDir, DEFAULT_SOUL_FILENAME);
+        if (fs.existsSync(soulPath)) {
+            const raw = fs.readFileSync(soulPath, "utf8").trim();
+            if (raw.length > 0) {
+                soulContext = raw.length > 500 ? raw.slice(0, 500) + "..." : raw;
+            }
+        }
+    }
+    catch {
+        // Ignore — SOUL.md is optional
+    }
+    try {
+        await ensureTaskmasterModelsJson(cfg, agentDir);
+        const authStorage = new AuthStorage(path.join(agentDir, "auth.json"));
+        const modelRegistry = new ModelRegistry(authStorage, path.join(agentDir, "models.json"));
+        const model = modelRegistry.find("anthropic", GREETING_MODEL);
+        if (!model) {
+            return fallbackGreeting(name);
+        }
+        const apiKeyInfo = await getApiKeyForModel({ model, cfg, agentDir });
+        const apiKey = requireApiKey(apiKeyInfo, model.provider);
+        authStorage.setRuntimeApiKey(model.provider, apiKey);
+        const prompt = soulContext
+            ? `Assistant name: "${name}"\n\nPersona/role:\n${soulContext}\n\nGenerate a greeting:`
+            : `Assistant name: "${name}"\n\nGenerate a greeting:`;
+        const context = {
+            systemPrompt: SYSTEM_PROMPT,
+            messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
+        };
+        const message = (await Promise.race([
+            complete(model, context, {
+                apiKey,
+                maxTokens: 80,
+                temperature: 0.7,
+            }),
+            new Promise((_, reject) => setTimeout(() => reject(new Error("Greeting generation timeout")), 8000)),
+        ]));
+        const content = message.content?.[0];
+        if (!content || content.type !== "text" || !content.text) {
+            return fallbackGreeting(name);
+        }
+        let text = content.text.trim();
+        // Strip quotes if wrapped
+        if ((text.startsWith('"') && text.endsWith('"')) ||
+            (text.startsWith("'") && text.endsWith("'"))) {
+            text = text.slice(1, -1).trim();
+        }
+        return { ok: true, greeting: text };
+    }
+    catch {
+        return fallbackGreeting(name);
+    }
+}
+function fallbackGreeting(name) {
+    return { ok: true, greeting: `Hi, I'm ${name}. How can I help you today?` };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/taskmaster",
-  "version": "1.9.5",
+  "version": "1.9.7",
   "description": "AI-powered business assistant for small businesses",
   "publishConfig": {
     "access": "public"
@@ -75,7 +75,8 @@
     "dist/whatsapp/**",
     "dist/records/**",
     "dist/filler/**",
-    "dist/license/**"
+    "dist/license/**",
+    "dist/suggestions/**"
   ],
   "scripts": {
     "dev": "node scripts/run-node.mjs",