@rubytech/taskmaster 1.0.106 → 1.0.108

package/dist/gateway/server-methods/browser-screencast.js

@@ -61,7 +61,7 @@ export const browserScreencastHandlers = {
             respond(true, result);
         }
         catch (err) {
-            log.error(`screencast.start failed: ${err}`);
+            log.error(`screencast.start failed: ${String(err)}`);
             respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, String(err)));
         }
     },
@@ -84,7 +84,7 @@ export const browserScreencastHandlers = {
             respond(true, { ok: true });
         }
         catch (err) {
-            log.error(`screencast.stop failed: ${err}`);
+            log.error(`screencast.stop failed: ${String(err)}`);
             respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, String(err)));
         }
     },
@@ -169,7 +169,7 @@ async function resolveBridgeUrl(context) {
         log.warn(`browser config resolved but not usable: enabled=${resolved.enabled} controlUrl=${resolved.controlUrl ?? "null"}`);
     }
     catch (err) {
-        log.error(`failed to resolve browser config: ${err}`);
+        log.error(`failed to resolve browser config: ${String(err)}`);
     }
     return null;
 }

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

@@ -1,10 +1,13 @@
-import { resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../../agents/agent-scope.js";
+import fs from "node:fs";
+import path from "node:path";
+import { resolveAgentWorkspaceDir, resolveAgentWorkspaceRoot, resolveDefaultAgentId } from "../../agents/agent-scope.js";
 import { installSkill } from "../../agents/skills-install.js";
 import { buildWorkspaceSkillStatus } from "../../agents/skills-status.js";
-import { loadWorkspaceSkillEntries } from "../../agents/skills.js";
+import { loadWorkspaceSkillEntries, resolveBundledSkillsDir } from "../../agents/skills.js";
+import { bumpSkillsSnapshotVersion } from "../../agents/skills/refresh.js";
 import { loadConfig, writeConfigFile } from "../../config/config.js";
 import { getRemoteSkillEligibility } from "../../infra/skills-remote.js";
-import { ErrorCodes, errorShape, formatValidationErrors, validateSkillsBinsParams, validateSkillsInstallParams, validateSkillsStatusParams, validateSkillsUpdateParams, } from "../protocol/index.js";
+import { ErrorCodes, errorShape, formatValidationErrors, validateSkillsBinsParams, validateSkillsCreateParams, validateSkillsDeleteDraftParams, validateSkillsDeleteParams, validateSkillsDraftsParams, validateSkillsInstallParams, validateSkillsReadParams, validateSkillsStatusParams, validateSkillsUpdateParams, } from "../protocol/index.js";
 function listWorkspaceDirs(cfg) {
     const dirs = new Set();
     const list = cfg.agents?.list;
@@ -45,6 +48,21 @@ function collectSkillBins(entries) {
     }
     return [...bins].sort();
 }
+function resolveWorkspaceRoot(cfg) {
+    return resolveAgentWorkspaceRoot(cfg, resolveDefaultAgentId(cfg));
+}
+function isPreloadedSkill(skillKey) {
+    const dir = resolveBundledSkillsDir();
+    if (!dir)
+        return false;
+    try {
+        return fs.existsSync(`${dir}/${skillKey}`) &&
+            fs.statSync(`${dir}/${skillKey}`).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
 export const skillsHandlers = {
     "skills.status": ({ params, respond }) => {
         if (!validateSkillsStatusParams(params)) {
@@ -97,6 +115,10 @@ export const skillsHandlers = {
             return;
         }
         const p = params;
+        if (p.enabled === false && isPreloadedSkill(p.skillKey)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "preloaded skills cannot be disabled"));
+            return;
+        }
         const cfg = loadConfig();
         const skills = cfg.skills ? { ...cfg.skills } : {};
         const entries = skills.entries ? { ...skills.entries } : {};
@@ -134,4 +156,138 @@ export const skillsHandlers = {
         await writeConfigFile(nextConfig);
         respond(true, { ok: true, skillKey: p.skillKey, config: current }, undefined);
     },
+    "skills.read": ({ params, respond }) => {
+        if (!validateSkillsReadParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid skills.read params: ${formatValidationErrors(validateSkillsReadParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const cfg = loadConfig();
+        const root = resolveWorkspaceRoot(cfg);
+        const skillDir = path.join(root, "skills", p.name);
+        const skillFile = path.join(skillDir, "SKILL.md");
+        if (!fs.existsSync(skillFile)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `skill "${p.name}" not found`));
+            return;
+        }
+        const content = fs.readFileSync(skillFile, "utf-8");
+        const references = [];
+        const refsDir = path.join(skillDir, "references");
+        if (fs.existsSync(refsDir) && fs.statSync(refsDir).isDirectory()) {
+            for (const entry of fs.readdirSync(refsDir, { withFileTypes: true })) {
+                if (entry.isFile() && entry.name.endsWith(".md")) {
+                    references.push({
+                        name: entry.name,
+                        content: fs.readFileSync(path.join(refsDir, entry.name), "utf-8"),
+                    });
+                }
+            }
+            references.sort((a, b) => a.name.localeCompare(b.name));
+        }
+        respond(true, { name: p.name, content, references }, undefined);
+    },
+    "skills.create": async ({ params, respond }) => {
+        if (!validateSkillsCreateParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid skills.create params: ${formatValidationErrors(validateSkillsCreateParams.errors)}`));
+            return;
+        }
+        const p = params;
+        if (isPreloadedSkill(p.name)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "cannot overwrite a preloaded skill"));
+            return;
+        }
+        const cfg = loadConfig();
+        const root = resolveWorkspaceRoot(cfg);
+        const skillDir = path.join(root, "skills", p.name);
+        // If the skill already exists (user skill), remove it first so we get a clean replace
+        if (fs.existsSync(skillDir)) {
+            fs.rmSync(skillDir, { recursive: true, force: true });
+        }
+        fs.mkdirSync(skillDir, { recursive: true });
+        fs.writeFileSync(path.join(skillDir, "SKILL.md"), p.skillContent, "utf-8");
+        if (p.references && p.references.length > 0) {
+            const refsDir = path.join(skillDir, "references");
+            fs.mkdirSync(refsDir, { recursive: true });
+            for (const ref of p.references) {
+                const safeName = ref.name.replace(/[^a-zA-Z0-9._-]/g, "-");
+                fs.writeFileSync(path.join(refsDir, safeName), ref.content, "utf-8");
+            }
+        }
+        bumpSkillsSnapshotVersion();
+        respond(true, { ok: true, name: p.name }, undefined);
+    },
+    "skills.delete": async ({ params, respond }) => {
+        if (!validateSkillsDeleteParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid skills.delete params: ${formatValidationErrors(validateSkillsDeleteParams.errors)}`));
+            return;
+        }
+        const p = params;
+        if (isPreloadedSkill(p.name)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "preloaded skills cannot be deleted"));
+            return;
+        }
+        const cfg = loadConfig();
+        const root = resolveWorkspaceRoot(cfg);
+        const skillDir = path.join(root, "skills", p.name);
+        if (!fs.existsSync(skillDir)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `skill "${p.name}" not found`));
+            return;
+        }
+        fs.rmSync(skillDir, { recursive: true, force: true });
+        bumpSkillsSnapshotVersion();
+        respond(true, { ok: true, name: p.name }, undefined);
+    },
+    "skills.drafts": ({ params, respond }) => {
+        if (!validateSkillsDraftsParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid skills.drafts params: ${formatValidationErrors(validateSkillsDraftsParams.errors)}`));
+            return;
+        }
+        const cfg = loadConfig();
+        const root = resolveWorkspaceRoot(cfg);
+        const draftsDir = path.join(root, ".skill-drafts");
+        if (!fs.existsSync(draftsDir)) {
+            respond(true, { drafts: [] }, undefined);
+            return;
+        }
+        const drafts = [];
+        for (const entry of fs.readdirSync(draftsDir, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const skillFile = path.join(draftsDir, entry.name, "SKILL.md");
+            if (!fs.existsSync(skillFile))
+                continue;
+            const skillContent = fs.readFileSync(skillFile, "utf-8");
+            const references = [];
+            const refsDir = path.join(draftsDir, entry.name, "references");
+            if (fs.existsSync(refsDir) && fs.statSync(refsDir).isDirectory()) {
+                for (const ref of fs.readdirSync(refsDir, { withFileTypes: true })) {
+                    if (ref.isFile() && ref.name.endsWith(".md")) {
+                        references.push({
+                            name: ref.name,
+                            content: fs.readFileSync(path.join(refsDir, ref.name), "utf-8"),
+                        });
+                    }
+                }
+                references.sort((a, b) => a.name.localeCompare(b.name));
+            }
+            drafts.push({ name: entry.name, skillContent, references });
+        }
+        respond(true, { drafts }, undefined);
+    },
+    "skills.deleteDraft": ({ params, respond }) => {
+        if (!validateSkillsDeleteDraftParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid skills.deleteDraft params: ${formatValidationErrors(validateSkillsDeleteDraftParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const cfg = loadConfig();
+        const root = resolveWorkspaceRoot(cfg);
+        const draftDir = path.join(root, ".skill-drafts", p.name);
+        if (!fs.existsSync(draftDir)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `draft "${p.name}" not found`));
+            return;
+        }
+        fs.rmSync(draftDir, { recursive: true, force: true });
+        respond(true, { ok: true, name: p.name }, undefined);
+    },
 };

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

@@ -56,7 +56,7 @@ function sanitiseName(raw) {
  * or the agent subdirectory (e.g. ~/taskmaster/agents/public).
  * We normalise to the root by stripping a trailing /agents/{name} suffix.
  */
-function resolveWorkspaceRoot(agentWorkspaceDir, agentId) {
+function resolveWorkspaceRoot(agentWorkspaceDir, _agentId) {
     const normalised = agentWorkspaceDir.replace(/\/+$/, "");
     // Check if the path ends with /agents/{something} — that's the agent subdir, not the workspace root
     const agentsMatch = normalised.match(/^(.+)\/agents\/[^/]+$/);
@@ -424,9 +424,9 @@ export const workspacesHandlers = {
             cfg = {
                 ...cfg,
                 channels: {
-                    ...(cfg.channels ?? {}),
+                    ...cfg.channels,
                     whatsapp: {
-                        ...(cfg.channels?.whatsapp ?? {}),
+                        ...cfg.channels?.whatsapp,
                         accounts: {
                             ...existingAccounts,
                             [whatsappAccountId]: {
@@ -467,7 +467,7 @@ export const workspacesHandlers = {
         if (typeof rawName === "string" && rawName.trim() && rawName.trim() !== name) {
             cfg = {
                 ...cfg,
-                workspaces: { ...(cfg.workspaces ?? {}), [name]: { displayName: rawName.trim() } },
+                workspaces: { ...cfg.workspaces, [name]: { displayName: rawName.trim() } },
             };
         }
         // Write config and schedule restart
@@ -582,12 +582,12 @@ export const workspacesHandlers = {
             }
             // Clean up empty accounts object
             if (Object.keys(whatsappAccounts).length === 0) {
-                const whatsappConfig = { ...(cfg.channels?.whatsapp ?? {}) };
+                const whatsappConfig = { ...cfg.channels?.whatsapp };
                 delete whatsappConfig.accounts;
                 cfg = {
                     ...cfg,
                     channels: {
-                        ...(cfg.channels ?? {}),
+                        ...cfg.channels,
                         whatsapp: whatsappConfig,
                     },
                 };
@@ -640,7 +640,7 @@ export const workspacesHandlers = {
         if (!requireBaseHash(params, snapshot, respond))
             return;
         let cfg = snapshot.config;
-        cfg = { ...cfg, workspaces: { ...(cfg.workspaces ?? {}), [name]: { displayName } } };
+        cfg = { ...cfg, workspaces: { ...cfg.workspaces, [name]: { displayName } } };
         try {
             await writeConfigFile(cfg);
         }

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

@@ -41,6 +41,11 @@ const BASE_METHODS = [
     "skills.bins",
     "skills.install",
     "skills.update",
+    "skills.read",
+    "skills.create",
+    "skills.delete",
+    "skills.drafts",
+    "skills.deleteDraft",
     "update.status",
     "update.run",
     "voicewake.get",

package/dist/gateway/server-methods.js

@@ -36,6 +36,7 @@ import { publicChatHandlers } from "./server-methods/public-chat.js";
 import { tailscaleHandlers } from "./server-methods/tailscale.js";
 import { wifiHandlers } from "./server-methods/wifi.js";
 import { workspacesHandlers } from "./server-methods/workspaces.js";
+import { brandHandlers } from "./server-methods/brand.js";
 const ADMIN_SCOPE = "operator.admin";
 const READ_SCOPE = "operator.read";
 const WRITE_SCOPE = "operator.write";
@@ -236,6 +237,7 @@ export const coreGatewayHandlers = {
     ...memoryHandlers,
     ...recordsHandlers,
     ...workspacesHandlers,
+    ...brandHandlers,
     ...publicChatHandlers,
     ...tailscaleHandlers,
     ...wifiHandlers,

package/dist/gateway/server.impl.js

@@ -428,7 +428,7 @@ export async function startGatewayServer(port = 18789, opts = {}) {
     const logMemory = log.child("memory");
     const agentIds = listAgentIds(cfgAtStart);
     for (const agentId of agentIds) {
-        getMemorySearchManager({ cfg: cfgAtStart, agentId }).then(async (result) => {
+        void getMemorySearchManager({ cfg: cfgAtStart, agentId }).then(async (result) => {
             if (result.manager) {
                 logMemory.info(`initialized for agent: ${agentId}`);
                 // Sync memory index on startup

package/dist/infra/heartbeat-runner.js

@@ -25,6 +25,7 @@ import { resolveHeartbeatVisibility } from "./heartbeat-visibility.js";
 import { requestHeartbeatNow, setHeartbeatWakeHandler, } from "./heartbeat-wake.js";
 import { deliverOutboundPayloads } from "./outbound/deliver.js";
 import { resolveHeartbeatDeliveryTarget, resolveHeartbeatSenderContext, } from "./outbound/targets.js";
+import { maybeNotifyUpdateAvailable } from "./heartbeat-update-notify.js";
 const log = createSubsystemLogger("gateway/heartbeat");
 let heartbeatsEnabled = true;
 export function setHeartbeatsEnabled(enabled) {
@@ -621,6 +622,14 @@ export async function runHeartbeatOnce(opts) {
         return { status: "failed", reason };
     }
 }
+async function checkAndNotifyUpdate(cfg, agent, deps) {
+    const agentId = agent.agentId;
+    const heartbeat = agent.heartbeat;
+    const { entry } = resolveHeartbeatSession(cfg, agentId, heartbeat);
+    const bindingAccountId = resolveAgentBoundAccountId(cfg, agentId, "whatsapp") ?? undefined;
+    const delivery = resolveHeartbeatDeliveryTarget({ cfg, entry, heartbeat, bindingAccountId });
+    await maybeNotifyUpdateAvailable({ cfg, delivery, deps });
+}
 export function startHeartbeatRunner(opts) {
     const runtime = opts.runtime ?? defaultRuntime;
     const runOnce = opts.runOnce ?? runHeartbeatOnce;
@@ -742,6 +751,14 @@ export function startHeartbeatRunner(opts) {
             if (res.status === "ran")
                 ran = true;
         }
+        // After heartbeat cycle: check for software updates and notify admin.
+        // Uses the first agent's delivery target. Non-blocking — never delays the next heartbeat.
+        if (ran) {
+            const firstAgent = state.agents.values().next().value;
+            if (firstAgent) {
+                void checkAndNotifyUpdate(state.cfg, firstAgent, { runtime: state.runtime }).catch(() => { });
+            }
+        }
         scheduleNext();
         if (ran)
             return { status: "ran", durationMs: Date.now() - startedAt };

package/dist/infra/heartbeat-update-notify.js

@@ -0,0 +1,120 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getChannelPlugin } from "../channels/plugins/index.js";
+import { resolveStateDir } from "../config/paths.js";
+import { createSubsystemLogger } from "../logging/subsystem.js";
+import { VERSION } from "../version.js";
+import { compareSemverStrings, resolveNpmChannelTag } from "./update-check.js";
+import { normalizeUpdateChannel, DEFAULT_PACKAGE_CHANNEL } from "./update-channels.js";
+import { deliverOutboundPayloads } from "./outbound/deliver.js";
+const log = createSubsystemLogger("gateway/heartbeat-update-notify");
+// Registry check interval during heartbeat cycles.
+// Shorter than the 24h startup check — the admin may publish frequently.
+const REGISTRY_CHECK_INTERVAL_MS = 4 * 60 * 60 * 1000; // 4 hours
+// In-memory: last time we checked the registry.
+let lastRegistryCheckMs = 0;
+// State file stores lastNotifiedVersion so we don't re-notify after restart
+// for a version we already told the admin about.
+const STATE_FILENAME = "update-check.json";
+async function readState() {
+    try {
+        const statePath = path.join(resolveStateDir(), STATE_FILENAME);
+        const raw = await fs.readFile(statePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+async function writeState(state) {
+    const statePath = path.join(resolveStateDir(), STATE_FILENAME);
+    await fs.mkdir(path.dirname(statePath), { recursive: true });
+    await fs.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
+}
+/**
+ * Check for available software updates and notify the admin via the heartbeat
+ * delivery channel. Designed to run after each heartbeat cycle.
+ *
+ * - Checks the NPM registry at most once per REGISTRY_CHECK_INTERVAL_MS.
+ * - Notifies the admin once per new version (persisted across restarts).
+ * - Never throws — errors are logged and swallowed.
+ */
+export async function maybeNotifyUpdateAvailable(params) {
+    try {
+        const { cfg, delivery, deps } = params;
+        const nowMs = params.nowMs ?? Date.now();
+        // Skip if no delivery target
+        if (delivery.channel === "none" || !delivery.to)
+            return false;
+        // Skip if disabled via config
+        if (cfg.update?.checkOnStart === false)
+            return false;
+        // Rate-limit registry checks
+        if (nowMs - lastRegistryCheckMs < REGISTRY_CHECK_INTERVAL_MS)
+            return false;
+        lastRegistryCheckMs = nowMs;
+        // Resolve update channel and fetch latest version
+        const channel = normalizeUpdateChannel(cfg.update?.channel) ?? DEFAULT_PACKAGE_CHANNEL;
+        const resolved = await resolveNpmChannelTag({ channel, timeoutMs: 3500 });
+        if (!resolved.version)
+            return false;
+        // Compare versions
+        const cmp = compareSemverStrings(VERSION, resolved.version);
+        if (cmp === null || cmp >= 0)
+            return false; // up to date or parse failure
+        // Check if we already notified for this version
+        const state = await readState();
+        if (state.lastNotifiedVersion === resolved.version)
+            return false;
+        // Check channel readiness
+        const plugin = getChannelPlugin(delivery.channel);
+        if (plugin?.heartbeat?.checkReady) {
+            const readiness = await plugin.heartbeat.checkReady({
+                cfg,
+                accountId: delivery.accountId,
+                deps,
+            });
+            if (!readiness.ok) {
+                log.debug("update notification skipped: channel not ready", {
+                    reason: readiness.reason,
+                });
+                return false;
+            }
+        }
+        // Send the notification
+        const message = `Taskmaster v${resolved.version} is available (you're on v${VERSION}). ` +
+            `Update from Setup → Software Update, or say "update software".`;
+        await deliverOutboundPayloads({
+            cfg,
+            channel: delivery.channel,
+            to: delivery.to,
+            accountId: delivery.accountId,
+            payloads: [{ text: message }],
+            deps,
+        });
+        // Persist so we don't re-notify after restart
+        await writeState({
+            ...state,
+            lastNotifiedVersion: resolved.version,
+            lastNotifiedTag: resolved.tag,
+            lastCheckedAt: new Date(nowMs).toISOString(),
+        });
+        log.info("update notification sent", {
+            current: VERSION,
+            latest: resolved.version,
+            to: delivery.to,
+        });
+        return true;
+    }
+    catch (err) {
+        log.error("update notification failed", {
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return false;
+    }
+}
+/** Reset in-memory check timer. Exposed for testing. */
+export function resetUpdateCheckTimer() {
+    lastRegistryCheckMs = 0;
+}

package/dist/infra/tunnel.js

@@ -79,7 +79,7 @@ export class CloudflareTunnel {
             const urlTimeout = setTimeout(() => {
                 if (!urlFound) {
                     reject(new Error("Timeout waiting for tunnel URL"));
-                    this.stop();
+                    void this.stop();
                 }
             }, 30000);
             this.process.stdout?.on("data", (data) => {

package/dist/memory/embeddings.js

@@ -33,10 +33,6 @@ function canAutoSelectLocal(options) {
         return false;
     }
 }
-function isMissingApiKeyError(err) {
-    const message = formatError(err);
-    return message.includes("No API key found for provider");
-}
 /**
  * Deduplicates concurrent model downloads. When multiple agents resolve the
  * same model path, only one download runs; the rest await the same promise.

package/dist/memory/manager.js

@@ -74,6 +74,15 @@ function expandPathTemplate(pattern, ctx) {
         result = result.replaceAll("{agentId}", ctx.agentId);
     return result;
 }
+/**
+ * Ensure phone numbers in memory/users/ paths include the canonical + prefix.
+ * AI agents sometimes omit the + when constructing paths (e.g. "memory/users/447734875155/...")
+ * but the session peer and filesystem convention always use + (e.g. "+447734875155").
+ * Without this, scope patterns like memory/users/{peer}/** won't match the path.
+ */
+function normalizePhoneInMemoryPath(relPath) {
+    return relPath.replace(/^(memory\/users\/)(\d)/i, "$1+$2");
+}
 /**
  * Simple glob pattern matcher supporting * and **.
  * - * matches any characters except /
@@ -85,7 +94,7 @@ function matchGlobPattern(pattern, filePath) {
     // Replace ** with a placeholder, then * with [^/]*, then placeholder with .*
     regexStr = regexStr.replace(/\*\*/g, "\0");
     regexStr = regexStr.replace(/\*/g, "[^/]*");
-    regexStr = regexStr.replace(/\0/g, ".*");
+    regexStr = regexStr.replaceAll("\0", ".*");
     const regex = new RegExp(`^${regexStr}$`, "i");
     return regex.test(filePath);
 }
@@ -517,7 +526,7 @@ export class MemoryIndexManager {
         return this.syncing;
     }
     async readFile(params) {
-        const relPath = normalizeRelPath(params.relPath);
+        const relPath = normalizePhoneInMemoryPath(normalizeRelPath(params.relPath));
         if (!relPath || !isMemoryPath(relPath)) {
             throw new Error("path required");
         }
@@ -552,7 +561,7 @@ export class MemoryIndexManager {
      * matching the session's scope configuration.
      */
     async writeFile(params) {
-        const relPath = normalizeRelPath(params.relPath);
+        const relPath = normalizePhoneInMemoryPath(normalizeRelPath(params.relPath));
         if (!relPath || !isMemoryPath(relPath)) {
             throw new Error("path required (must be in memory/ directory)");
         }
@@ -573,7 +582,7 @@ export class MemoryIndexManager {
         }
         // Ensure parent directory exists
         const parentDir = path.dirname(absPath);
-        await ensureDir(parentDir);
+        ensureDir(parentDir);
         // Write or append content
         const mode = params.mode ?? "overwrite";
         if (mode === "append") {
@@ -598,7 +607,7 @@ export class MemoryIndexManager {
         let relPath;
         if (params.destFolder) {
             // Explicit folder — use as-is (scope checking enforces access)
-            relPath = `${params.destFolder}/${params.destFilename}`;
+            relPath = normalizePhoneInMemoryPath(`${params.destFolder}/${params.destFilename}`);
         }
         else {
             // Default: memory/users/{peer}/media/{filename}
@@ -629,7 +638,7 @@ export class MemoryIndexManager {
         }
         // Ensure parent directory exists
         const parentDir = path.dirname(absPath);
-        await ensureDir(parentDir);
+        ensureDir(parentDir);
         // Copy the file
         await fs.copyFile(params.sourcePath, absPath);
         return { path: relPath, bytesWritten: sourceStat.size };

package/dist/web/inbound/media.js

@@ -55,7 +55,7 @@ export async function downloadInboundMedia(msg, sock) {
         log.info(`audioMessage: ptt=${audio.ptt}, url=${audio.url ? "present" : "missing"}, ` +
             `directPath=${audio.directPath ? "present" : "missing"}, ` +
             `mediaKey=${audio.mediaKey ? "present" : "missing"}, ` +
-            `fileLength=${audio.fileLength}, seconds=${audio.seconds}`);
+            `fileLength=${String(audio.fileLength)}, seconds=${String(audio.seconds)}`);
     }
     try {
         // Try standard download first

package/dist/web/login-qr.js

@@ -44,29 +44,6 @@ function attachLoginWaiter(accountId, login) {
         current.errorStatus = getStatusCode(err);
     });
 }
-async function restartLoginSocket(login, runtime) {
-    if (login.restartAttempted)
-        return false;
-    login.restartAttempted = true;
-    runtime.log(info("WhatsApp asked for a restart after pairing (code 515); retrying connection once…"));
-    closeSocket(login.sock);
-    try {
-        const sock = await createWaSocket(false, login.verbose, {
-            authDir: login.authDir,
-        });
-        login.sock = sock;
-        login.connected = false;
-        login.error = undefined;
-        login.errorStatus = undefined;
-        attachLoginWaiter(login.accountId, login);
-        return true;
-    }
-    catch (err) {
-        login.error = formatError(err);
-        login.errorStatus = getStatusCode(err);
-        return false;
-    }
-}
 export async function startWebLoginWithQr(opts = {}) {
     const runtime = opts.runtime ?? defaultRuntime;
     const cfg = loadConfig();

package/dist/web/providers/cloud/receive.js

@@ -59,7 +59,7 @@ function extractMessageText(message) {
             // Reactions are handled separately
             return "";
         default:
-            return `<${message.type}>`;
+            return `<${String(message.type)}>`;
     }
 }
 /**

package/dist/web/providers/cloud/webhook.js

@@ -67,7 +67,7 @@ export function createWebhookHandlers(options) {
         try {
             const payload = req.body;
             if (payload.object !== "whatsapp_business_account") {
-                log.warn(`Unexpected webhook object type: ${payload.object}`);
+                log.warn(`Unexpected webhook object type: ${String(payload.object)}`);
                 return;
             }
             for (const entry of payload.entry) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/taskmaster",
-  "version": "1.0.106",
+  "version": "1.0.108",
   "description": "AI-powered business assistant for small businesses",
   "publishConfig": {
     "access": "public"