twinclaw 1.1.1 → 1.1.2

package/README.md

@@ -37,11 +37,11 @@ When you first run TwinClaw, it will automatically start a **Guided Setup Wizard
 3.  **Security**: Generates a master encryption key for your local vault.
 4.  **Skills**: Auto-registers built-in skills for immediate use.
 
-TwinClaw now defaults to `dmPolicy: "pairing"` for Telegram/WhatsApp DMs. Unknown senders receive a pairing code and must be explicitly approved:
+TwinClaw now defaults to `dmPolicy: "allowlist"` for Telegram/WhatsApp DMs. Only allowlisted users can message the bot. Unknown senders must be explicitly added:
 
 ```powershell
-node src/index.ts pairing list telegram
-node src/index.ts pairing approve telegram <CODE>
+node src/index.ts allowlist add telegram <userId>
+node src/index.ts allowlist list telegram
 ```
 
 ---

package/dist/api/handlers/agents.js

@@ -0,0 +1,82 @@
+import { sendOk, sendError } from '../shared.js';
+/** GET /agents — List all sub-agents */
+export function handleAgentsList(deps) {
+    return (_req, res) => {
+        const agents = deps.subAgentService.list();
+        const data = {
+            agents: agents.map((agent) => ({
+                id: agent.id,
+                name: agent.name,
+                model: agent.model,
+                status: agent.status,
+                createdAt: agent.createdAt.toISOString(),
+                startedAt: agent.startedAt?.toISOString() ?? null,
+                completedAt: agent.completedAt?.toISOString() ?? null,
+                error: agent.error,
+                steps: agent.steps.length,
+            })),
+            total: agents.length,
+            running: agents.filter((a) => a.status === 'running').length,
+            completed: agents.filter((a) => a.status === 'completed').length,
+            failed: agents.filter((a) => a.status === 'failed').length,
+            cancelled: agents.filter((a) => a.status === 'cancelled').length,
+        };
+        sendOk(res, data);
+    };
+}
+/** GET /agents/:id — Get a specific agent */
+export function handleAgentsGet(deps) {
+    return (req, res) => {
+        const id = req.params.id;
+        const agent = deps.subAgentService.get(id);
+        if (!agent) {
+            sendError(res, `Agent not found: ${id}`, 404);
+            return;
+        }
+        const data = {
+            id: agent.id,
+            name: agent.name,
+            model: agent.model,
+            systemPrompt: agent.systemPrompt,
+            maxSteps: agent.maxSteps,
+            timeoutMs: agent.timeoutMs,
+            reportBackTo: agent.reportBackTo,
+            status: agent.status,
+            createdAt: agent.createdAt.toISOString(),
+            startedAt: agent.startedAt?.toISOString() ?? null,
+            completedAt: agent.completedAt?.toISOString() ?? null,
+            result: agent.result,
+            error: agent.error,
+            steps: agent.steps.map((step) => ({
+                step: step.step,
+                action: step.action,
+                observation: step.observation,
+                startedAt: step.startedAt.toISOString(),
+                completedAt: step.completedAt?.toISOString() ?? null,
+            })),
+        };
+        sendOk(res, data);
+    };
+}
+/** POST /agents/:id/cancel — Cancel a running agent */
+export function handleAgentsCancel(deps) {
+    return (req, res) => {
+        const id = req.params.id;
+        const agent = deps.subAgentService.get(id);
+        if (!agent) {
+            sendError(res, `Agent not found: ${id}`, 404);
+            return;
+        }
+        if (agent.status !== 'running') {
+            sendError(res, `Agent ${id} is not running (status: ${agent.status})`, 400);
+            return;
+        }
+        const cancelled = deps.subAgentService.cancel(id);
+        if (cancelled) {
+            sendOk(res, { message: `Agent ${id} cancelled`, agentId: id });
+        }
+        else {
+            sendError(res, `Failed to cancel agent ${id}`, 500);
+        }
+    };
+}

package/dist/api/handlers/debug.js

@@ -0,0 +1,69 @@
+import { sendOk, sendError } from '../shared.js';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+/** GET /debug — Extended diagnostics including full context budget, recent logs, active connections, performance metrics */
+export function handleDebug(deps) {
+    return async (req, res) => {
+        try {
+            const limit = typeof req.query.limit === 'string'
+                ? Math.min(500, Math.max(1, parseInt(req.query.limit, 10) || 50))
+                : 50;
+            const budgetFull = deps.budgetGovernor?.getSnapshot('health');
+            const routingTelemetry = deps.modelRouter?.getHealthSnapshot();
+            const logs = await getRecentLogs(limit);
+            const debugData = {
+                system: {
+                    platform: os.platform(),
+                    arch: os.arch(),
+                    cpus: os.cpus().length,
+                    totalMemoryMb: Math.round(os.totalmem() / 1024 / 1024),
+                    freeMemoryMb: Math.round(os.freemem() / 1024 / 1024),
+                    uptimeSec: os.uptime(),
+                    nodeVersion: process.version,
+                },
+                runtime: {
+                    memoryUsageMb: Math.round(process.memoryUsage().rss / 1024 / 1024),
+                    heapUsedMb: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
+                    heapTotalMb: Math.round(process.memoryUsage().heapTotal / 1024 / 1024),
+                    externalMb: Math.round(process.memoryUsage().external / 1024 / 1024),
+                    arrayBuffersMb: Math.round((process.memoryUsage().arrayBuffers ?? 0) / 1024 / 1024),
+                },
+                budget: budgetFull ? {
+                    context: budgetFull,
+                } : undefined,
+                routing: routingTelemetry ? {
+                    telemetry: routingTelemetry,
+                } : undefined,
+                recentLogs: logs,
+            };
+            sendOk(res, debugData);
+        }
+        catch (err) {
+            sendError(res, `Failed to get debug info: ${err instanceof Error ? err.message : String(err)}`, 500);
+        }
+    };
+}
+async function getRecentLogs(limit) {
+    try {
+        const dateIso = new Date().toISOString().slice(0, 10);
+        const logPath = path.resolve('memory', `${dateIso}.md`);
+        const content = await readFile(logPath, 'utf8').catch(() => '');
+        if (!content) {
+            return [];
+        }
+        const sections = content.split(/\n## /).filter(Boolean);
+        return sections.slice(-limit).map((s) => {
+            const [header, ...bodyLines] = s.split('\n');
+            const [type, timestamp] = header.split(' @ ');
+            return {
+                timestamp: timestamp || new Date().toISOString(),
+                level: type.toUpperCase(),
+                message: bodyLines.join('\n').trim(),
+            };
+        }).reverse();
+    }
+    catch {
+        return [];
+    }
+}

package/dist/api/handlers/devices.js

@@ -0,0 +1,79 @@
+import { sendOk, sendError } from '../shared.js';
+/** GET /devices — List all paired devices */
+export function handleDevicesList(deps) {
+    return (_req, res) => {
+        const devices = deps.devicePairingService.list();
+        const data = {
+            devices: devices.map((device) => ({
+                deviceId: device.deviceId,
+                displayName: device.displayName,
+                platform: device.platform,
+                clientMode: device.clientMode,
+                roles: device.roles,
+                status: device.status,
+                capabilities: device.capabilities,
+                lastSeenAt: device.lastSeenAt ?? null,
+                pairedAt: device.pairedAt ?? null,
+            })),
+            total: devices.length,
+            paired: devices.filter((d) => d.status === 'paired').length,
+            disconnected: devices.filter((d) => d.status === 'disconnected').length,
+            revoked: devices.filter((d) => d.status === 'revoked').length,
+        };
+        sendOk(res, data);
+    };
+}
+/** GET /devices/:id — Get a specific device */
+export function handleDevicesGet(deps) {
+    return (req, res) => {
+        const deviceId = req.params.id;
+        const device = deps.devicePairingService.get(deviceId);
+        if (!device) {
+            sendError(res, `Device not found: ${deviceId}`, 404);
+            return;
+        }
+        const data = {
+            deviceId: device.deviceId,
+            displayName: device.displayName,
+            platform: device.platform,
+            clientId: device.clientId,
+            clientMode: device.clientMode,
+            roles: device.roles,
+            scopes: device.scopes,
+            capabilities: device.capabilities,
+            status: device.status,
+            lastSeenAt: device.lastSeenAt ?? null,
+            pairedAt: device.pairedAt ?? null,
+            createdAt: device.createdAt,
+        };
+        sendOk(res, data);
+    };
+}
+/** POST /devices/:id/command — Send a command to a device */
+export function handleDevicesCommand(deps) {
+    return async (req, res) => {
+        const deviceId = req.params.id;
+        const { command, args } = req.body;
+        if (!command || typeof command !== 'string') {
+            sendError(res, 'Required field: command (string)', 400);
+            return;
+        }
+        try {
+            const result = await deps.devicePairingService.executeCommand(deviceId, command, args);
+            if (result.success) {
+                sendOk(res, {
+                    deviceId,
+                    command,
+                    output: result.output,
+                });
+            }
+            else {
+                sendError(res, result.error || 'Command execution failed', 400);
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            sendError(res, `Command execution failed: ${message}`, 500);
+        }
+    };
+}

package/dist/api/handlers/jobs.js

@@ -0,0 +1,99 @@
+import { sendOk, sendError } from '../shared.js';
+/** GET /jobs — List all scheduled jobs */
+export function handleJobsList(deps) {
+    return (_req, res) => {
+        const jobs = deps.scheduler.listJobs();
+        const data = {
+            jobs: jobs.map((job) => ({
+                id: job.id,
+                cronExpression: job.cronExpression,
+                description: job.description,
+                status: job.status,
+                lastRunAt: job.lastRunAt?.toISOString() ?? null,
+                lastError: job.lastError,
+            })),
+            total: jobs.length,
+            running: jobs.filter((j) => j.status === 'running').length,
+            idle: jobs.filter((j) => j.status === 'idle').length,
+            error: jobs.filter((j) => j.status === 'error').length,
+        };
+        sendOk(res, data);
+    };
+}
+/** GET /jobs/:id — Get a specific job */
+export function handleJobsGet(deps) {
+    return (req, res) => {
+        const id = req.params.id;
+        const job = deps.scheduler.getJob(id);
+        if (!job) {
+            sendError(res, `Job not found: ${id}`, 404);
+            return;
+        }
+        const data = {
+            id: job.id,
+            cronExpression: job.cronExpression,
+            description: job.description,
+            status: job.status,
+            lastRunAt: job.lastRunAt?.toISOString() ?? null,
+            lastError: job.lastError,
+        };
+        sendOk(res, data);
+    };
+}
+/** POST /jobs/:id/run — Trigger a job manually */
+export function handleJobsRun(deps) {
+    return async (req, res) => {
+        const id = req.params.id;
+        const job = deps.scheduler.getJob(id);
+        if (!job) {
+            sendError(res, `Job not found: ${id}`, 404);
+            return;
+        }
+        try {
+            deps.scheduler.start(id);
+            sendOk(res, { message: `Job ${id} triggered successfully`, jobId: id });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            sendError(res, `Failed to run job: ${message}`, 500);
+        }
+    };
+}
+/** POST /jobs/:id/start — Start a stopped job */
+export function handleJobsStart(deps) {
+    return (req, res) => {
+        const id = req.params.id;
+        const job = deps.scheduler.getJob(id);
+        if (!job) {
+            sendError(res, `Job not found: ${id}`, 404);
+            return;
+        }
+        try {
+            deps.scheduler.start(id);
+            sendOk(res, { message: `Job ${id} started`, jobId: id });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            sendError(res, `Failed to start job: ${message}`, 500);
+        }
+    };
+}
+/** POST /jobs/:id/stop — Stop a running job */
+export function handleJobsStop(deps) {
+    return (req, res) => {
+        const id = req.params.id;
+        const job = deps.scheduler.getJob(id);
+        if (!job) {
+            sendError(res, `Job not found: ${id}`, 404);
+            return;
+        }
+        try {
+            deps.scheduler.stop(id);
+            sendOk(res, { message: `Job ${id} stopped`, jobId: id });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            sendError(res, `Failed to stop job: ${message}`, 500);
+        }
+    };
+}

package/dist/api/handlers/status.js

@@ -0,0 +1,149 @@
+import { getSecretVaultService } from '../../services/secret-vault.js';
+import { sendOk } from '../shared.js';
+const startTime = Date.now();
+function getVersion() {
+    try {
+        const pkg = JSON.parse(require.resolve('../../package.json').replace('file://', ''));
+        return pkg.version ?? '1.0.0';
+    }
+    catch {
+        return '1.0.0';
+    }
+}
+/** GET /status — Unified diagnostics view combining health + budget + routing + jobs + agents + devices */
+export function handleStatus(deps) {
+    return async (_req, res) => {
+        const summary = deps.skillRegistry.summary();
+        const servers = deps.mcpManager.listServers();
+        const packageDiagnostics = await deps.mcpManager.getSkillPackageDiagnostics();
+        const secretDiagnostics = getSecretVaultService().getDiagnostics(['API_SECRET']);
+        const budgetSnapshot = deps.budgetGovernor?.getSnapshot('health');
+        const routingSnapshot = deps.modelRouter?.getHealthSnapshot();
+        const backupDiagnostics = deps.localStateBackup
+            ? await deps.localStateBackup.getDiagnostics(5)
+            : null;
+        const heartbeatRunning = deps.heartbeat.scheduler
+            .listJobs()
+            .some((j) => j.status === 'running');
+        const healthData = {
+            status: servers.some((s) => s.state === 'error') ||
+                packageDiagnostics.blockedPackageCount > 0 ||
+                secretDiagnostics.health.hasIssues ||
+                budgetSnapshot?.directive.severity === 'hard_limit' ||
+                (routingSnapshot?.consecutiveFailures ?? 0) >= 3 ||
+                backupDiagnostics?.status === 'degraded'
+                ? 'degraded'
+                : 'ok',
+            uptimeSec: Math.floor((Date.now() - startTime) / 1000),
+            memoryUsageMb: Math.round(process.memoryUsage().rss / 1024 / 1024),
+            heartbeat: { running: heartbeatRunning },
+            skills: {
+                builtin: summary.builtin ?? 0,
+                mcp: summary.mcp ?? 0,
+                total: deps.skillRegistry.size,
+            },
+            skillPackages: {
+                installed: packageDiagnostics.installed.length,
+                active: packageDiagnostics.activePackageCount,
+                blocked: packageDiagnostics.blockedPackageCount,
+                warnings: packageDiagnostics.warnings,
+                violations: packageDiagnostics.violations.map((violation) => ({
+                    packageName: violation.packageName,
+                    version: violation.version,
+                    code: violation.code,
+                    message: violation.message,
+                    remediation: violation.remediation,
+                })),
+            },
+            secrets: {
+                status: secretDiagnostics.health.hasIssues ? 'degraded' : 'ok',
+                missingRequired: secretDiagnostics.health.missingRequired,
+                expired: secretDiagnostics.health.expired,
+                warnings: secretDiagnostics.health.warnings,
+                total: secretDiagnostics.total,
+                active: secretDiagnostics.active,
+                dueForRotation: secretDiagnostics.dueForRotation,
+            },
+            budget: budgetSnapshot
+                ? {
+                    severity: budgetSnapshot.directive.severity,
+                    profile: budgetSnapshot.directive.profile,
+                    pacingDelayMs: budgetSnapshot.directive.pacingDelayMs,
+                    manualProfile: budgetSnapshot.manualProfile,
+                    daily: budgetSnapshot.daily,
+                    session: budgetSnapshot.session,
+                    providers: budgetSnapshot.providers,
+                }
+                : undefined,
+            routing: routingSnapshot,
+            backups: backupDiagnostics
+                ? {
+                    status: backupDiagnostics.status,
+                    lastSnapshotAt: backupDiagnostics.lastSnapshotAt,
+                    lastRestoreAt: backupDiagnostics.lastRestoreAt,
+                    validationFailureCount: backupDiagnostics.validationFailureCount,
+                    recommendationCount: backupDiagnostics.recommendations.length,
+                }
+                : undefined,
+            mcpServers: servers.map((s) => ({
+                id: s.id,
+                name: s.name,
+                state: s.state,
+                toolCount: s.toolCount,
+                health: {
+                    circuit: s.health.state,
+                    failureCount: s.health.metrics.failureCount,
+                    remainingCooldownMs: s.health.remainingCooldownMs,
+                },
+            })),
+        };
+        const jobList = deps.jobScheduler?.listJobs() ?? [];
+        const agentList = deps.subAgentService?.list() ?? [];
+        const deviceList = deps.devicePairingService?.list() ?? [];
+        const currentIncidents = deps.incidentManager?.getCurrentIncidents() ?? [];
+        const data = {
+            status: healthData.status,
+            uptimeSec: healthData.uptimeSec,
+            memoryUsageMb: healthData.memoryUsageMb,
+            version: getVersion(),
+            health: healthData,
+            jobs: {
+                count: jobList.length,
+                list: jobList.map((j) => ({
+                    id: j.id,
+                    cronExpression: j.cronExpression,
+                    description: j.description,
+                    status: j.status,
+                    lastRunAt: j.lastRunAt?.toISOString() ?? null,
+                    lastError: j.lastError,
+                })),
+            },
+            agents: {
+                count: agentList.length,
+                list: agentList.map((a) => ({
+                    id: a.id,
+                    name: a.name,
+                    status: a.status,
+                    createdAt: a.createdAt.toISOString(),
+                    startedAt: a.startedAt?.toISOString(),
+                    completedAt: a.completedAt?.toISOString(),
+                })),
+            },
+            devices: {
+                count: deviceList.length,
+                list: deviceList.map((d) => ({
+                    deviceId: d.deviceId,
+                    displayName: d.displayName,
+                    platform: d.platform,
+                    status: d.status,
+                    lastSeenAt: d.lastSeenAt,
+                })),
+            },
+            incidents: {
+                safeMode: deps.incidentManager?.isSafeModeEnabled() ?? false,
+                count: currentIncidents.length,
+            },
+        };
+        sendOk(res, data);
+    };
+}