@crewx/cli 0.8.0-rc.66 → 0.8.0-rc.82

package/dist/commands/task-db.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * Shared SQLite helper for ps/kill/result CLI commands.
+ * Reads from (or writes to) the global ~/.crewx/crewx.db
+ * populated by SqliteTracingPlugin.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDbPath = getDbPath;
+exports.openDb = openDb;
+exports.getRunningTasks = getRunningTasks;
+exports.getAllTasks = getAllTasks;
+exports.getTask = getTask;
+exports.killTask = killTask;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+function getDbPath(dbRoot) {
+    return (0, path_1.join)(dbRoot ?? (0, os_1.homedir)(), '.crewx', 'crewx.db');
+}
+function openDb(readonly = true, dbRoot) {
+    const dbPath = getDbPath(dbRoot);
+    if (!(0, fs_1.existsSync)(dbPath))
+        return null;
+    return new better_sqlite3_1.default(dbPath, { readonly });
+}
+/** Return all tasks with status='running'. */
+function getRunningTasks(dbRoot) {
+    const db = openDb(true, dbRoot);
+    if (!db)
+        return [];
+    try {
+        return db.prepare(`SELECT id, agent_id, prompt, mode, status, pid, started_at, completed_at,
+              result, error, duration_ms
+       FROM tasks WHERE status = 'running' ORDER BY started_at DESC`).all();
+    }
+    finally {
+        db.close();
+    }
+}
+/** Return all tasks ordered by started_at desc. */
+function getAllTasks(dbRoot) {
+    const db = openDb(true, dbRoot);
+    if (!db)
+        return [];
+    try {
+        return db.prepare(`SELECT id, agent_id, prompt, mode, status, pid, started_at, completed_at,
+              result, error, duration_ms
+       FROM tasks ORDER BY started_at DESC`).all();
+    }
+    finally {
+        db.close();
+    }
+}
+/** Return a single task by id, or undefined if not found. */
+function getTask(id, dbRoot) {
+    const db = openDb(true, dbRoot);
+    if (!db)
+        return undefined;
+    try {
+        return db.prepare(`SELECT id, agent_id, prompt, mode, status, pid, started_at, completed_at,
+              result, error, duration_ms
+       FROM tasks WHERE id = ?`).get(id);
+    }
+    finally {
+        db.close();
+    }
+}
+/** Send SIGTERM to the task's pid and mark it failed. Returns ok/message. */
+function killTask(id, dbRoot) {
+    const db = openDb(false, dbRoot);
+    if (!db)
+        return { ok: false, message: `crewx.db not found — no running tasks.` };
+    try {
+        const task = db.prepare(`SELECT id, status, pid FROM tasks WHERE id = ?`).get(id);
+        if (!task) {
+            return { ok: false, message: `Task not found: ${id}` };
+        }
+        if (task.status !== 'running') {
+            return { ok: false, message: `Task ${id} is not running (status: ${task.status})` };
+        }
+        if (task.pid) {
+            try {
+                process.kill(task.pid, 'SIGTERM');
+            }
+            catch (err) {
+                const code = err.code;
+                if (code !== 'ESRCH') {
+                    return {
+                        ok: false,
+                        message: `Failed to kill PID ${task.pid}: ${err instanceof Error ? err.message : String(err)}`,
+                    };
+                }
+                // ESRCH = process already gone — still clean up the record
+            }
+        }
+        db.prepare(`UPDATE tasks SET status='failed', error='killed by user',
+       completed_at=?, pid=NULL WHERE id=?`).run(new Date().toISOString(), id);
+        return { ok: true, message: `Killed task ${id}${task.pid ? ` (PID: ${task.pid})` : ''}` };
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/examples/deny-secrets-plugin.d.ts

@@ -0,0 +1,22 @@
+/**
+ * DenyIfTouchesSecretsPlugin — Phase 0 demo HookPlugin.
+ *
+ * Denies Bash tool calls whose command string contains ".env".
+ * Pure string matching — trivially bypassable (see README).
+ *
+ * SECURITY NOTE:
+ *   Do NOT include tool.input content in deny reasons.
+ *   Use static messages only to prevent prompt injection.
+ *   ✅ return ctx.deny('Secrets-related command');
+ *   ❌ return ctx.deny(`Blocked: ${cmd}`);
+ */
+import { HookPlugin } from '@crewx/sdk/hooks';
+import type { HookContext, HookResult } from '@crewx/sdk/hooks';
+export declare class DenyIfTouchesSecretsPlugin extends HookPlugin {
+    readonly name = "deny-secrets";
+    readonly version = "0.1.0";
+    readonly capabilities: {
+        required: readonly ["deny"];
+    };
+    run(ctx: HookContext): Promise<HookResult>;
+}

package/dist/examples/deny-secrets-plugin.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * DenyIfTouchesSecretsPlugin — Phase 0 demo HookPlugin.
+ *
+ * Denies Bash tool calls whose command string contains ".env".
+ * Pure string matching — trivially bypassable (see README).
+ *
+ * SECURITY NOTE:
+ *   Do NOT include tool.input content in deny reasons.
+ *   Use static messages only to prevent prompt injection.
+ *   ✅ return ctx.deny('Secrets-related command');
+ *   ❌ return ctx.deny(`Blocked: ${cmd}`);
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DenyIfTouchesSecretsPlugin = void 0;
+const hooks_1 = require("@crewx/sdk/hooks");
+const SECRET_PATTERNS = ['.env', 'credentials.json', 'service-account-key.json'];
+const SHELL_TOOL_NAMES = new Set(['Bash', 'shell', 'local_shell']);
+class DenyIfTouchesSecretsPlugin extends hooks_1.HookPlugin {
+    name = 'deny-secrets';
+    version = '0.1.0';
+    capabilities = { required: ['deny'] };
+    async run(ctx) {
+        if (!SHELL_TOOL_NAMES.has(ctx.tool.rawName) && ctx.tool.name !== 'shell') {
+            return ctx.pass();
+        }
+        const input = ctx.tool.input;
+        const command = input?.command;
+        if (typeof command !== 'string') {
+            return ctx.pass();
+        }
+        for (const pattern of SECRET_PATTERNS) {
+            if (command.includes(pattern)) {
+                return ctx.deny('Secrets-related command');
+            }
+        }
+        return ctx.pass();
+    }
+}
+exports.DenyIfTouchesSecretsPlugin = DenyIfTouchesSecretsPlugin;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { handleInit, type InitResult } from './commands/init';

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleInit = void 0;
+var init_1 = require("./commands/init");
+Object.defineProperty(exports, "handleInit", { enumerable: true, get: function () { return init_1.handleInit; } });

package/dist/logging.d.ts

@@ -0,0 +1,21 @@
+/**
+ * CLI file-based logging for CrewX SDK events.
+ *
+ * Subscribe to task:start / task:end events from a Crewx instance
+ * and write structured log files to .crewx/logs/ in the workspace root.
+ *
+ * File name format: {YYYYMMDDTHHmmss}_{traceId}.log
+ * e.g. 20260412T145044_tsk_AbCdEfGh.log
+ *
+ * Format mirrors cli-bak TaskManagementService for backward compatibility.
+ */
+import type { Crewx } from '@crewx/sdk';
+/**
+ * Attach file-based logging to a Crewx instance.
+ * Subscribes to task:start and task:end events and writes log files.
+ *
+ * @param crewx - The Crewx instance to attach logging to
+ * @param workspaceRoot - Root directory for .crewx/logs/ (default: process.cwd())
+ * @returns Cleanup function that removes all event listeners
+ */
+export declare function attachFileLogger(crewx: Crewx, workspaceRoot?: string): () => void;

package/dist/logging.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * CLI file-based logging for CrewX SDK events.
+ *
+ * Subscribe to task:start / task:end events from a Crewx instance
+ * and write structured log files to .crewx/logs/ in the workspace root.
+ *
+ * File name format: {YYYYMMDDTHHmmss}_{traceId}.log
+ * e.g. 20260412T145044_tsk_AbCdEfGh.log
+ *
+ * Format mirrors cli-bak TaskManagementService for backward compatibility.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachFileLogger = attachFileLogger;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const CREWX_VERSION = '0.9.0-alpha.1';
+/** Format Date as YYYYMMDDTHHmmss (local time) */
+function formatTimestamp(date) {
+    const pad = (n) => String(n).padStart(2, '0');
+    return (`${date.getFullYear()}` +
+        `${pad(date.getMonth() + 1)}` +
+        `${pad(date.getDate())}` +
+        `T${pad(date.getHours())}` +
+        `${pad(date.getMinutes())}` +
+        `${pad(date.getSeconds())}`);
+}
+function ensureLogsDir(logsDir) {
+    if (!(0, fs_1.existsSync)(logsDir)) {
+        (0, fs_1.mkdirSync)(logsDir, { recursive: true });
+    }
+}
+/**
+ * Attach file-based logging to a Crewx instance.
+ * Subscribes to task:start and task:end events and writes log files.
+ *
+ * @param crewx - The Crewx instance to attach logging to
+ * @param workspaceRoot - Root directory for .crewx/logs/ (default: process.cwd())
+ * @returns Cleanup function that removes all event listeners
+ */
+function attachFileLogger(crewx, workspaceRoot) {
+    const logsDir = (0, path_1.join)(workspaceRoot ?? process.cwd(), '.crewx', 'logs');
+    // traceId → absolute log file path (in-memory map for the process lifetime)
+    const logFiles = new Map();
+    const unsubStart = crewx.on('task:start', (event) => {
+        try {
+            ensureLogsDir(logsDir);
+            const ts = formatTimestamp(event.timestamp);
+            const logFile = (0, path_1.join)(logsDir, `${ts}_${event.traceId}.log`);
+            logFiles.set(event.traceId, logFile);
+            const header = `=== TASK LOG: ${event.traceId} ===\n` +
+                `CrewX Version: ${CREWX_VERSION}\n` +
+                `Mode: ${event.mode}\n` +
+                `Agent: ${event.agentRef}\n` +
+                `Started: ${event.timestamp.toLocaleString()}\n` +
+                `Message: ${event.message}\n` +
+                `\n`;
+            (0, fs_1.writeFileSync)(logFile, header, { encoding: 'utf8', mode: 0o600 });
+        }
+        catch {
+            // Non-fatal: CLI logging must never crash the main process
+        }
+    });
+    const unsubEnd = crewx.on('task:end', (event) => {
+        try {
+            const logFile = logFiles.get(event.traceId);
+            if (!logFile)
+                return;
+            const ts = new Date().toLocaleString();
+            const status = event.error
+                ? `failed: ${event.error.message}`
+                : 'completed successfully';
+            const completion = `[${ts}] INFO: Task ${status} in ${event.durationMs}ms\n` +
+                `[${ts}] INFO: Process closed with exit code: ${event.error ? 1 : 0}\n`;
+            (0, fs_1.appendFileSync)(logFile, completion, 'utf8');
+            logFiles.delete(event.traceId);
+        }
+        catch {
+            // Non-fatal
+        }
+    });
+    return () => {
+        unsubStart();
+        unsubEnd();
+    };
+}

package/dist/main.d.ts

@@ -1 +1,11 @@
+#!/usr/bin/env node
+/**
+ * CrewX CLI entry point.
+ * Dispatches commands to the appropriate handler.
+ *
+ * Boot sequence:
+ *   1. Inject CREWX_CLI / CREWX_WORKSPACE env defaults (must be first)
+ *   2. Parse command
+ *   3. Dispatch to handler
+ */
 export {};