@rubytech/taskmaster 1.2.0 → 1.3.0

package/dist/agents/tools/file-list-tool.js

@@ -0,0 +1,127 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { realpath } from "node:fs/promises";
+import { Type } from "@sinclair/typebox";
+import { resolveAgentWorkspaceRoot, resolveSessionAgentId } from "../agent-scope.js";
+import { jsonResult, readStringParam, readNumberParam } from "./common.js";
+const FileListSchema = Type.Object({
+    path: Type.Optional(Type.String({
+        description: "Directory to list, relative to the workspace root " +
+            "(e.g. 'memory/users', 'skills'). Defaults to the workspace root.",
+    })),
+    depth: Type.Optional(Type.Number({
+        description: "How many levels deep to recurse. 1 = immediate children only (default). " +
+            "Use 2–3 for a broader view. Maximum 5.",
+    })),
+});
+function isInsideRoot(target, root) {
+    const prefix = root.endsWith("/") ? root : `${root}/`;
+    return target === root || target.startsWith(prefix);
+}
+async function listDir(dirPath, currentDepth, maxDepth) {
+    let entries;
+    try {
+        entries = await fs.readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const result = [];
+    // Sort: directories first, then files, alphabetical within each group
+    const sorted = [...entries].sort((a, b) => {
+        const aDir = a.isDirectory() || a.isSymbolicLink() ? 0 : 1;
+        const bDir = b.isDirectory() || b.isSymbolicLink() ? 0 : 1;
+        if (aDir !== bDir)
+            return aDir - bDir;
+        return String(a.name).localeCompare(String(b.name));
+    });
+    for (const entry of sorted) {
+        const name = String(entry.name);
+        const fullPath = path.join(dirPath, name);
+        const item = {
+            name,
+            type: entry.isDirectory() ? "directory" : entry.isSymbolicLink() ? "symlink" : "file",
+        };
+        if (entry.isFile()) {
+            try {
+                const stat = await fs.stat(fullPath);
+                item.size = stat.size;
+            }
+            catch {
+                // stat failed — skip size
+            }
+        }
+        if ((entry.isDirectory() || entry.isSymbolicLink()) && currentDepth < maxDepth) {
+            item.children = await listDir(fullPath, currentDepth + 1, maxDepth);
+        }
+        result.push(item);
+    }
+    return result;
+}
+export function createFileListTool(options) {
+    return {
+        label: "File List",
+        name: "file_list",
+        description: "List files and folders in the workspace. " +
+            "Path is relative to the workspace root. " +
+            "Returns names, types (file/directory/symlink), and sizes. " +
+            "Use depth > 1 to see nested contents.",
+        parameters: FileListSchema,
+        execute: async (_toolCallId, args) => {
+            const params = args;
+            const rawPath = readStringParam(params, "path") ?? "";
+            const rawDepth = readNumberParam(params, "depth", { integer: true });
+            const maxDepth = Math.max(1, Math.min(rawDepth ?? 1, 5));
+            // ── Resolve workspace root ──────────────────────────────────
+            const cfg = options?.config;
+            if (!cfg) {
+                return jsonResult({ error: "No config available — cannot resolve workspace." });
+            }
+            const agentId = resolveSessionAgentId({
+                sessionKey: options?.agentSessionKey,
+                config: cfg,
+            });
+            const workspaceRoot = resolveAgentWorkspaceRoot(cfg, agentId);
+            // ── Normalise and resolve target ────────────────────────────
+            if (rawPath.includes("\0")) {
+                return jsonResult({ error: "Invalid path." });
+            }
+            const resolved = rawPath ? path.resolve(workspaceRoot, rawPath) : workspaceRoot;
+            // ── Containment check ───────────────────────────────────────
+            let realTarget;
+            try {
+                realTarget = await realpath(resolved);
+            }
+            catch {
+                return jsonResult({ error: `Not found: ${rawPath || "/"}` });
+            }
+            let realRoot;
+            try {
+                realRoot = await realpath(workspaceRoot);
+            }
+            catch {
+                return jsonResult({ error: "Workspace root is not accessible." });
+            }
+            if (!isInsideRoot(realTarget, realRoot)) {
+                return jsonResult({ error: "Path is outside the workspace." });
+            }
+            // ── Verify it's a directory ─────────────────────────────────
+            try {
+                const stat = await fs.stat(realTarget);
+                if (!stat.isDirectory()) {
+                    return jsonResult({ error: `Not a directory: ${rawPath}` });
+                }
+            }
+            catch {
+                return jsonResult({ error: `Not found: ${rawPath || "/"}` });
+            }
+            // ── List ────────────────────────────────────────────────────
+            const entries = await listDir(realTarget, 1, maxDepth);
+            return jsonResult({
+                path: rawPath || "/",
+                depth: maxDepth,
+                entries,
+            });
+        },
+    };
+}

package/dist/auto-reply/reply/commands-tts.js

@@ -115,6 +115,7 @@ export const handleTtsCommands = async (params, allowTextCommands) => {
                 .filter((provider) => isTtsProviderConfigured(config, provider));
             const hasOpenAI = Boolean(resolveTtsApiKey(config, "openai"));
             const hasElevenLabs = Boolean(resolveTtsApiKey(config, "elevenlabs"));
+            const hasHume = Boolean(resolveTtsApiKey(config, "hume"));
             const hasEdge = isTtsProviderConfigured(config, "edge");
             return {
                 shouldContinue: false,
@@ -124,13 +125,17 @@ export const handleTtsCommands = async (params, allowTextCommands) => {
                         `Fallbacks: ${fallback.join(", ") || "none"}\n` +
                         `OpenAI key: ${hasOpenAI ? "✅" : "❌"}\n` +
                         `ElevenLabs key: ${hasElevenLabs ? "✅" : "❌"}\n` +
+                        `Hume key: ${hasHume ? "✅" : "❌"}\n` +
                         `Edge enabled: ${hasEdge ? "✅" : "❌"}\n` +
-                        `Usage: /tts provider openai | elevenlabs | edge`,
+                        `Usage: /tts provider openai | elevenlabs | hume | edge`,
                 },
             };
         }
         const requested = args.trim().toLowerCase();
-        if (requested !== "openai" && requested !== "elevenlabs" && requested !== "edge") {
+        if (requested !== "openai" &&
+            requested !== "elevenlabs" &&
+            requested !== "hume" &&
+            requested !== "edge") {
             return { shouldContinue: false, reply: ttsUsage() };
         }
         setTtsProvider(prefsPath, requested);

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.2.0",
-  "commit": "8cc810fa3a5317aec897706a333f431ee3e61995",
-  "builtAt": "2026-02-24T14:07:31.816Z"
+  "version": "1.3.0",
+  "commit": "6432fa8c1f6f007fcdbee8123de84e0f8450d01c",
+  "builtAt": "2026-02-24T20:07:40.938Z"
 }

package/dist/cli/provision-seed.js

@@ -134,12 +134,10 @@ export function buildDefaultAgentList(workspaceRoot) {
                 "current_time",
                 "sessions_list",
                 "sessions_history",
-                "sessions_send",
                 "session_status",
                 "cron",
                 "license_generate",
-                "contact_lookup",
-                "contact_update",
+                "group:contacts",
                 "authorize_admin",
                 "revoke_admin",
                 "list_admins",

package/dist/commands/doctor-config-flow.js

@@ -1,4 +1,5 @@
 import { TaskmasterSchema, CONFIG_PATH_TASKMASTER, migrateLegacyConfig, readConfigFileSnapshot, } from "../config/config.js";
+import { reconcileAgentContactTools } from "../config/agent-tools-reconcile.js";
 import { applyPluginAutoEnable } from "../config/plugin-auto-enable.js";
 import { formatCliCommand } from "../cli/command-format.js";
 import { note } from "../terminal/note.js";
@@ -156,6 +157,18 @@ export async function loadAndMaybeMigrateDoctorConfig(params) {
             fixHints.push(`Run "${formatCliCommand("taskmaster doctor --fix")}" to apply these changes.`);
         }
     }
+    const toolReconcile = reconcileAgentContactTools({ config: candidate });
+    if (toolReconcile.changes.length > 0) {
+        note(toolReconcile.changes.join("\n"), "Doctor changes");
+        candidate = toolReconcile.config;
+        pendingChanges = true;
+        if (shouldRepair) {
+            cfg = toolReconcile.config;
+        }
+        else {
+            fixHints.push(`Run "${formatCliCommand("taskmaster doctor --fix")}" to apply these changes.`);
+        }
+    }
     const unknown = stripUnknownConfigKeys(candidate);
     if (unknown.removed.length > 0) {
         const lines = unknown.removed.map((path) => `- ${path}`).join("\n");

package/dist/config/agent-tools-reconcile.js

@@ -0,0 +1,53 @@
+/**
+ * Individual contact tool names that should be replaced by `group:contacts`.
+ * Order does not matter — all are removed and replaced with the group.
+ */
+const INDIVIDUAL_CONTACT_TOOLS = [
+    "contact_create",
+    "contact_delete",
+    "contact_lookup",
+    "contact_update",
+];
+function isAdminAgent(agent) {
+    const id = agent.id?.trim() ?? "";
+    return id === "admin" || id.endsWith("-admin");
+}
+/**
+ * Ensure admin agents use `group:contacts` instead of individual contact tools.
+ *
+ * Runs unconditionally on gateway startup (like `applyPluginAutoEnable`).
+ * Idempotent — if the allow list already contains `group:contacts`, no changes.
+ */
+export function reconcileAgentContactTools(params) {
+    const config = structuredClone(params.config);
+    const changes = [];
+    const agents = config.agents?.list;
+    if (!Array.isArray(agents))
+        return { config, changes };
+    for (const agent of agents) {
+        if (!agent || !isAdminAgent(agent))
+            continue;
+        const allow = agent.tools?.allow;
+        if (!Array.isArray(allow))
+            continue;
+        // Already using the group — nothing to do
+        if (allow.includes("group:contacts"))
+            continue;
+        // Check if any individual contact tools are present
+        const hasAny = INDIVIDUAL_CONTACT_TOOLS.some((t) => allow.includes(t));
+        if (!hasAny)
+            continue;
+        // Remove individual entries, add group
+        const removed = [];
+        for (const tool of INDIVIDUAL_CONTACT_TOOLS) {
+            const idx = allow.indexOf(tool);
+            if (idx !== -1) {
+                allow.splice(idx, 1);
+                removed.push(tool);
+            }
+        }
+        allow.push("group:contacts");
+        changes.push(`Replaced ${removed.join(", ")} with group:contacts in agent "${agent.id}" tools.allow.`);
+    }
+    return { config, changes };
+}

package/dist/config/defaults.js

@@ -1,6 +1,6 @@
 import { DEFAULT_CONTEXT_TOKENS } from "../agents/defaults.js";
 import { parseModelRef } from "../agents/model-selection.js";
-import { upsertAuthProfile } from "../agents/auth-profiles.js";
+import { upsertAuthProfile, removeAuthProfile } from "../agents/auth-profiles.js";
 import { resolveTalkApiKey } from "./talk.js";
 import { DEFAULT_AGENT_MAX_CONCURRENT, DEFAULT_SUBAGENT_MAX_CONCURRENT } from "./agent-limits.js";
 let defaultWarnState = { warned: false };
@@ -372,10 +372,19 @@ export function applyApiKeys(config) {
     const keys = config.apiKeys;
     if (!keys || Object.keys(keys).length === 0)
         return config;
+    const disabled = config.apiKeysDisabled ?? {};
     let cfg = config;
     for (const [provider, key] of Object.entries(keys)) {
         if (!key?.trim())
             continue;
+        if (disabled[provider]) {
+            // Actively remove auth profiles for disabled model providers so stale
+            // credentials from a previous config load don't persist in memory.
+            if (API_KEY_MODEL_PROVIDERS.has(provider)) {
+                removeAuthProfile({ profileId: `${provider}:api-key` });
+            }
+            continue;
+        }
         const trimmedKey = key.trim();
         if (API_KEY_MODEL_PROVIDERS.has(provider)) {
             upsertAuthProfile({

package/dist/config/legacy.migrations.part-3.js

@@ -216,4 +216,30 @@ export const LEGACY_CONFIG_MIGRATIONS_PART_3 = [
             }
         },
     },
+    {
+        id: "agents-tools-remove-sessions_send",
+        describe: "Remove sessions_send from agent tools.allow (tool removed for security)",
+        apply: (raw, changes) => {
+            const agents = getRecord(raw.agents);
+            const list = getAgentsList(agents);
+            for (const entry of list) {
+                if (!isRecord(entry))
+                    continue;
+                const id = typeof entry.id === "string" ? entry.id.trim() : "";
+                if (!id)
+                    continue;
+                const tools = getRecord(entry.tools);
+                if (!tools)
+                    continue;
+                if (!Array.isArray(tools.allow))
+                    continue;
+                const allow = tools.allow;
+                const index = allow.indexOf("sessions_send");
+                if (index !== -1) {
+                    allow.splice(index, 1);
+                    changes.push(`Removed sessions_send from agent "${id}" tools.allow.`);
+                }
+            }
+        },
+    },
 ];

package/dist/config/zod-schema.core.js

@@ -138,7 +138,7 @@ export const MarkdownConfigSchema = z
 })
     .strict()
     .optional();
-export const TtsProviderSchema = z.enum(["elevenlabs", "openai", "edge"]);
+export const TtsProviderSchema = z.enum(["elevenlabs", "openai", "hume", "edge"]);
 export const TtsModeSchema = z.enum(["final", "all"]);
 export const TtsAutoSchema = z.enum(["off", "always", "inbound", "tagged"]);
 export const TtsConfigSchema = z
@@ -191,6 +191,14 @@ export const TtsConfigSchema = z
     })
         .strict()
         .optional(),
+    hume: z
+        .object({
+        apiKey: z.string().optional(),
+        voice: z.string().optional(),
+        description: z.string().optional(),
+    })
+        .strict()
+        .optional(),
     edge: z
         .object({
         enabled: z.boolean().optional(),

package/dist/config/zod-schema.js

@@ -552,6 +552,7 @@ export const TaskmasterSchema = z
         .strict())
         .optional(),
     apiKeys: z.record(z.string(), z.string()).optional(),
+    apiKeysDisabled: z.record(z.string(), z.boolean()).optional(),
     access: z
         .object({
         masterPin: z