pragma-so 0.1.2 → 0.1.4

package/dist/server/conversation/prompts.js

@@ -184,8 +184,8 @@ function buildWorkerPrompt(input) {
         "If you changed code, submit at least one runnable validation command for the task window.",
         `For richer testing UIs with multiple processes and panels, use \`submit-testing-config\`:`,
         submitTestingConfigCommand,
-        `The config JSON has: \`processes\` (array of {name, command, cwd?, port?, ready_pattern?}) and \`panels\` (array of panel objects). Panel types: \`web-preview\` ({type, title, process, path?, devices?}), \`api-tester\` ({type, title, process, endpoints: [{method, path, description?, body?, headers?}]}), \`terminal\` ({type, title, command, cwd?}), \`log-viewer\` ({type, title, process}). Optional: \`setup\` (array of setup commands), \`layout\` ("tabs"|"grid").`,
-        `Example: \`--config '{"processes":[{"name":"server","command":"npm run dev","cwd":"code/my-app","port":3000,"ready_pattern":"ready on"}],"panels":[{"type":"web-preview","title":"App","process":"server"}]}'\``,
+        `The config JSON has: \`processes\` (array of {name, command, cwd?, ready_pattern?}) and \`panels\` (array of panel objects). Panel types: \`web-preview\` ({type, title, process, path?, devices?}), \`api-tester\` ({type, title, process, endpoints: [{method, path, description?, body?, headers?}]}), \`terminal\` ({type, title, command, cwd?}), \`log-viewer\` ({type, title, process}). Optional: \`setup\` (array of setup commands), \`layout\` ("tabs"|"grid").`,
+        `Example: \`--config '{"processes":[{"name":"server","command":"npm run dev","cwd":"code/my-app","ready_pattern":"ready on"}],"panels":[{"type":"web-preview","title":"App","process":"server"}]}'\``,
         `Fallback: for simple single-command cases, use:`,
         "Include the exact run directory for each command (for example: `--cwd \"code/default/my-app\"`):",
         submitTestsCommand,

package/dist/server/db.js

@@ -563,6 +563,24 @@ CREATE TABLE IF NOT EXISTS agent_connectors (
   connector_id VARCHAR(64) REFERENCES connectors(id) ON DELETE CASCADE,
   PRIMARY KEY (agent_id, connector_id)
 );
+`);
+    await db.exec(`
+CREATE TABLE IF NOT EXISTS processes (
+  id VARCHAR(64) PRIMARY KEY,
+  workspace VARCHAR(255) NOT NULL,
+  folder_name VARCHAR(255) NOT NULL,
+  label VARCHAR(255) NOT NULL,
+  command TEXT NOT NULL,
+  cwd TEXT NOT NULL,
+  type VARCHAR(16) NOT NULL DEFAULT 'service',
+  status VARCHAR(32) NOT NULL DEFAULT 'stopped',
+  pid INTEGER,
+  exit_code INTEGER,
+  task_id VARCHAR(64),
+  started_at TIMESTAMPTZ,
+  stopped_at TIMESTAMPTZ,
+  created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
 `);
 }
 async function ensureTaskStatusEnumType(db) {

package/dist/server/http/schemas.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dbQuerySchema = exports.assignAgentConnectorSchema = exports.configureConnectorSchema = exports.assignAgentSkillSchema = exports.updateSkillSchema = exports.createSkillSchema = exports.updateHumanSchema = exports.createHumanSchema = exports.updateContextFileSchema = exports.createContextFileSchema = exports.serviceStdinSchema = exports.testingProxyRequestSchema = exports.agentSubmitTestingConfigSchema = exports.testingConfigSchema = exports.runTaskTestCommandSchema = exports.createCodeFolderCopySchema = exports.createCodeRepoCloneSchema = exports.createContextFolderSchema = exports.plansQuerySchema = exports.chatsQuerySchema = exports.executeFromThreadSchema = exports.conversationTurnSchema = exports.outputFileQuerySchema = exports.openOutputFolderSchema = exports.reviewTaskSchema = exports.stopTaskSchema = exports.taskRespondSchema = exports.updateTaskTestCommandsSchema = exports.agentSubmitTestCommandsSchema = exports.agentRequestHelpSchema = exports.agentAskQuestionSchema = exports.executePlanProposalSchema = exports.planProposeSchema = exports.planSelectRecipientSchema = exports.agentSelectRecipientSchema = exports.setTaskRecipientSchema = exports.createFollowupTaskSchema = exports.createExecuteTaskSchema = exports.createTaskSchema = exports.tasksQuerySchema = exports.updateAgentSchema = exports.createAgentSchema = exports.setActiveWorkspaceSchema = exports.createWorkspaceSchema = void 0;
+exports.updateProcessSchema = exports.createProcessSchema = exports.dbQuerySchema = exports.assignAgentConnectorSchema = exports.configureConnectorSchema = exports.assignAgentSkillSchema = exports.updateSkillSchema = exports.createSkillSchema = exports.updateHumanSchema = exports.createHumanSchema = exports.updateContextFileSchema = exports.createContextFileSchema = exports.serviceStdinSchema = exports.testingProxyRequestSchema = exports.agentSubmitTestingConfigSchema = exports.testingConfigSchema = exports.runTaskTestCommandSchema = exports.createCodeFolderCopySchema = exports.createCodeRepoCloneSchema = exports.createContextFolderSchema = exports.plansQuerySchema = exports.chatsQuerySchema = exports.executeFromThreadSchema = exports.conversationTurnSchema = exports.outputFileQuerySchema = exports.openOutputFolderSchema = exports.reviewTaskSchema = exports.stopTaskSchema = exports.taskRespondSchema = exports.updateTaskTestCommandsSchema = exports.agentSubmitTestCommandsSchema = exports.agentRequestHelpSchema = exports.agentAskQuestionSchema = exports.executePlanProposalSchema = exports.planProposeSchema = exports.planSelectRecipientSchema = exports.agentSelectRecipientSchema = exports.setTaskRecipientSchema = exports.createFollowupTaskSchema = exports.createExecuteTaskSchema = exports.createTaskSchema = exports.tasksQuerySchema = exports.updateAgentSchema = exports.createAgentSchema = exports.setActiveWorkspaceSchema = exports.createWorkspaceSchema = void 0;
 const zod_1 = require("zod");
 const types_1 = require("../conversation/types");
 const adapterRegistry_1 = require("../conversation/adapterRegistry");
@@ -242,7 +242,7 @@ const testingProcessSchema = zod_1.z.object({
     name: nonEmptyString,
     command: nonEmptyString,
     cwd: nonEmptyString.optional(),
-    port: zod_1.z.number().int().positive().optional(),
+    port: zod_1.z.number().int().positive().optional(), // Ignored — server assigns ports automatically
     healthcheck: zod_1.z.string().optional(),
     ready_pattern: zod_1.z.string().optional(),
 }).strict();
@@ -366,3 +366,20 @@ exports.dbQuerySchema = zod_1.z
     params: zod_1.z.array(zod_1.z.unknown()).optional(),
 })
     .strict();
+const processTypeSchema = zod_1.z.enum(["service", "script"]);
+exports.createProcessSchema = zod_1.z
+    .object({
+    label: nonEmptyString,
+    command: nonEmptyString,
+    cwd: nonEmptyString,
+    type: processTypeSchema,
+})
+    .strict();
+exports.updateProcessSchema = zod_1.z
+    .object({
+    label: nonEmptyString.optional(),
+    command: nonEmptyString.optional(),
+    cwd: nonEmptyString.optional(),
+    type: processTypeSchema.optional(),
+})
+    .strict();

package/dist/server/index.js

@@ -7,6 +7,7 @@ exports.startServer = startServer;
 const node_child_process_1 = require("node:child_process");
 const node_crypto_1 = require("node:crypto");
 const promises_1 = require("node:fs/promises");
+const node_net_1 = __importDefault(require("node:net"));
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 const node_util_1 = require("node:util");
@@ -146,7 +147,6 @@ function escapeHtml(str) {
 const TASK_STATUS_LISTENERS = new Map();
 const THREAD_UPDATE_LISTENERS = new Map();
 const RUNTIME_SERVICES_BY_WORKSPACE = new Map();
-const MAX_RUNTIME_SERVICE_LOG_ENTRIES = 2000;
 function threadListenerKey(workspaceName, threadId) {
     return `${workspaceName}:${threadId}`;
 }
@@ -261,6 +261,16 @@ function createSSEStream(c, options) {
         unsubscribe();
     });
 }
+async function getRandomFreePort() {
+    return new Promise((resolve, reject) => {
+        const srv = node_net_1.default.createServer();
+        srv.listen(0, "127.0.0.1", () => {
+            const port = srv.address().port;
+            srv.close(() => resolve(port));
+        });
+        srv.on("error", reject);
+    });
+}
 function getWorkspaceServiceStore(workspaceName, createIfMissing = false) {
     const existing = RUNTIME_SERVICES_BY_WORKSPACE.get(workspaceName);
     if (existing) {
@@ -283,6 +293,7 @@ function toRuntimeServiceSummary(service) {
         cwd: service.cwd,
         status: service.status,
         pid: service.pid,
+        port: service.port,
         exit_code: service.exit_code,
         started_at: service.started_at,
         ended_at: service.ended_at,
@@ -321,9 +332,6 @@ function appendRuntimeServiceLog(service, stream, text) {
     };
     service.next_seq += 1;
     service.logs.push(entry);
-    if (service.logs.length > MAX_RUNTIME_SERVICE_LOG_ENTRIES) {
-        service.logs.splice(0, service.logs.length - MAX_RUNTIME_SERVICE_LOG_ENTRIES);
-    }
     publishRuntimeServiceEvent(service, { type: "log", entry });
 }
 function updateRuntimeServiceStatus(service, status, exitCode) {
@@ -334,6 +342,19 @@ function updateRuntimeServiceStatus(service, status, exitCode) {
         type: "status",
         service: toRuntimeServiceSummary(service),
     });
+    if (service.process_db_id) {
+        void updateProcessDbStatus(service.workspace, service.process_db_id, status, exitCode);
+    }
+}
+async function updateProcessDbStatus(workspaceName, processDbId, status, exitCode) {
+    try {
+        const db = await (0, db_1.openDatabase)(workspaceName);
+        const dbStatus = status === "ready" ? "running" : status;
+        await db.query(`UPDATE processes SET status = $1, exit_code = $2, stopped_at = CASE WHEN $1 IN ('stopped', 'exited') THEN CURRENT_TIMESTAMP ELSE stopped_at END WHERE id = $3`, [dbStatus, exitCode, processDbId]);
+    }
+    catch {
+        // Best-effort DB update
+    }
 }
 function startRuntimeService(input) {
     const serviceId = `svc_${(0, node_crypto_1.randomUUID)().slice(0, 12)}`;
@@ -347,6 +368,7 @@ function startRuntimeService(input) {
         cwd: input.requestedCwd,
         status: "running",
         pid: null,
+        port: input.port ?? null,
         exit_code: null,
         started_at: startedAt,
         ended_at: null,
@@ -472,9 +494,52 @@ async function recoverOrphanedTasks() {
         }
     }
 }
+async function recoverOrphanedProcesses() {
+    const workspaces = await (0, db_1.listWorkspaceNames)();
+    for (const workspaceName of workspaces) {
+        const db = await (0, db_1.openDatabase)(workspaceName);
+        const running = await db.query(`SELECT id, pid FROM processes WHERE status = 'running'`);
+        for (const row of running.rows) {
+            const pid = row.pid;
+            let alive = false;
+            if (pid && pid > 0) {
+                try {
+                    process.kill(pid, 0);
+                    alive = true;
+                }
+                catch {
+                    alive = false;
+                }
+            }
+            if (alive && pid) {
+                try {
+                    process.kill(pid, "SIGTERM");
+                }
+                catch {
+                    // already dead
+                }
+                // Give it a moment, then SIGKILL
+                setTimeout(() => {
+                    try {
+                        process.kill(pid, 0);
+                        process.kill(pid, "SIGKILL");
+                    }
+                    catch {
+                        // already dead
+                    }
+                }, 3000);
+            }
+            await db.query(`UPDATE processes SET status = 'exited', stopped_at = CURRENT_TIMESTAMP, exit_code = -1 WHERE id = $1`, [row.id]);
+        }
+        if (running.rows.length > 0) {
+            console.log(`[recovery] ${workspaceName}: cleaned up ${running.rows.length} orphaned process(es)`);
+        }
+    }
+}
 async function startServer(options) {
     await (0, db_1.setupPragma)();
     await recoverOrphanedTasks();
+    await recoverOrphanedProcesses();
     const apiUrl = process.env.PRAGMA_API_URL?.trim() || `http://127.0.0.1:${options.port}`;
     const pragmaCliCommand = (0, pragmaCli_1.resolvePragmaCliCommand)(__dirname);
     const executeRunner = new executeRunner_1.ExecuteRunner({
@@ -532,6 +597,8 @@ async function startServer(options) {
     app.use("/code/*", middleware_1.workspaceMiddleware);
     app.use("/context/*", middleware_1.workspaceMiddleware);
     app.use("/context", middleware_1.workspaceMiddleware);
+    app.use("/workspace/outputs/*", middleware_1.workspaceMiddleware);
+    app.use("/workspace/outputs/files", middleware_1.workspaceMiddleware);
     const turnRunner = new turnRunner_1.TurnRunner({
         apiUrl,
         pragmaCliCommand,
@@ -910,6 +977,155 @@ async function startServer(options) {
             },
         });
     });
+    // ── Process Management ─────────────────────────────────────────
+    app.get("/processes", async (c) => {
+        const workspaceName = c.get("workspace");
+        const db = c.get("db");
+        const result = await db.query(`SELECT * FROM processes WHERE workspace = $1 ORDER BY created_at DESC`, [workspaceName]);
+        return c.json({ processes: result.rows });
+    });
+    app.get("/code/folders/:folderName/processes", async (c) => {
+        const workspaceName = c.get("workspace");
+        const folderName = c.req.param("folderName");
+        const db = c.get("db");
+        const result = await db.query(`SELECT * FROM processes WHERE workspace = $1 AND folder_name = $2 ORDER BY created_at DESC`, [workspaceName, folderName]);
+        return c.json({ processes: result.rows });
+    });
+    app.post("/code/folders/:folderName/processes", (0, validators_1.validateJson)(schemas_1.createProcessSchema), async (c) => {
+        const workspaceName = c.get("workspace");
+        const folderName = c.req.param("folderName");
+        const db = c.get("db");
+        const body = c.req.valid("json");
+        const processId = `proc_${(0, node_crypto_1.randomUUID)().slice(0, 12)}`;
+        await db.query(`INSERT INTO processes (id, workspace, folder_name, label, command, cwd, type, status)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, 'stopped')`, [processId, workspaceName, folderName, body.label, body.command, body.cwd, body.type]);
+        const result = await db.query(`SELECT * FROM processes WHERE id = $1`, [processId]);
+        return c.json({ ok: true, process: result.rows[0] }, 201);
+    });
+    app.put("/processes/:processId", (0, validators_1.validateJson)(schemas_1.updateProcessSchema), async (c) => {
+        const db = c.get("db");
+        const processId = c.req.param("processId");
+        const body = c.req.valid("json");
+        const existing = await db.query(`SELECT status FROM processes WHERE id = $1`, [processId]);
+        if (existing.rows.length === 0) {
+            throw new db_1.PragmaError("PROCESS_NOT_FOUND", 404, `Process not found: ${processId}`);
+        }
+        if (existing.rows[0].status === "running") {
+            throw new db_1.PragmaError("PROCESS_RUNNING", 400, "Cannot update a running process.");
+        }
+        const updates = [];
+        const params = [];
+        let paramIndex = 1;
+        if (body.label !== undefined) {
+            updates.push(`label = $${paramIndex++}`);
+            params.push(body.label);
+        }
+        if (body.command !== undefined) {
+            updates.push(`command = $${paramIndex++}`);
+            params.push(body.command);
+        }
+        if (body.cwd !== undefined) {
+            updates.push(`cwd = $${paramIndex++}`);
+            params.push(body.cwd);
+        }
+        if (body.type !== undefined) {
+            updates.push(`type = $${paramIndex++}`);
+            params.push(body.type);
+        }
+        if (updates.length === 0) {
+            const result = await db.query(`SELECT * FROM processes WHERE id = $1`, [processId]);
+            return c.json({ ok: true, process: result.rows[0] });
+        }
+        params.push(processId);
+        await db.query(`UPDATE processes SET ${updates.join(", ")} WHERE id = $${paramIndex}`, params);
+        const result = await db.query(`SELECT * FROM processes WHERE id = $1`, [processId]);
+        return c.json({ ok: true, process: result.rows[0] });
+    });
+    app.delete("/processes/:processId", async (c) => {
+        const workspaceName = c.get("workspace");
+        const db = c.get("db");
+        const processId = c.req.param("processId");
+        const existing = await db.query(`SELECT status FROM processes WHERE id = $1`, [processId]);
+        if (existing.rows.length === 0) {
+            throw new db_1.PragmaError("PROCESS_NOT_FOUND", 404, `Process not found: ${processId}`);
+        }
+        // Stop if running
+        if (existing.rows[0].status === "running") {
+            const store = getWorkspaceServiceStore(workspaceName);
+            for (const service of store.values()) {
+                if (service.process_db_id === processId) {
+                    stopRuntimeService(service);
+                    break;
+                }
+            }
+        }
+        await db.query(`DELETE FROM processes WHERE id = $1`, [processId]);
+        return c.json({ ok: true });
+    });
+    app.post("/processes/:processId/start", async (c) => {
+        const workspaceName = c.get("workspace");
+        const db = c.get("db");
+        const processId = c.req.param("processId");
+        const workspacePaths = (0, db_1.getWorkspacePaths)(workspaceName);
+        const result = await db.query(`SELECT * FROM processes WHERE id = $1`, [processId]);
+        if (result.rows.length === 0) {
+            throw new db_1.PragmaError("PROCESS_NOT_FOUND", 404, `Process not found: ${processId}`);
+        }
+        const proc = result.rows[0];
+        if (proc.status === "running") {
+            throw new db_1.PragmaError("PROCESS_ALREADY_RUNNING", 400, "Process is already running.");
+        }
+        const absoluteCwd = (0, node_path_1.join)(workspacePaths.codeDir, proc.folder_name, proc.cwd === "." ? "" : proc.cwd);
+        const cwdInfo = await (0, promises_1.stat)(absoluteCwd).catch(() => null);
+        if (!cwdInfo?.isDirectory()) {
+            throw new db_1.PragmaError("PROCESS_CWD_NOT_FOUND", 400, `Working directory not found: ${absoluteCwd}`);
+        }
+        const service = startRuntimeService({
+            workspaceName,
+            taskId: "",
+            label: proc.label,
+            command: proc.command,
+            requestedCwd: proc.cwd,
+            absoluteCwd,
+            env: { ...process.env, PRAGMA_WORKSPACE_NAME: workspaceName },
+        });
+        service.process_db_id = processId;
+        await db.query(`UPDATE processes SET status = 'running', pid = $1, started_at = CURRENT_TIMESTAMP, stopped_at = NULL, exit_code = NULL WHERE id = $2`, [service.pid, processId]);
+        return c.json({ ok: true, service: toRuntimeServiceSummary(service) });
+    });
+    app.post("/processes/:processId/stop", async (c) => {
+        const workspaceName = c.get("workspace");
+        const db = c.get("db");
+        const processId = c.req.param("processId");
+        const result = await db.query(`SELECT id, status FROM processes WHERE id = $1`, [processId]);
+        if (result.rows.length === 0) {
+            throw new db_1.PragmaError("PROCESS_NOT_FOUND", 404, `Process not found: ${processId}`);
+        }
+        const store = getWorkspaceServiceStore(workspaceName);
+        for (const service of store.values()) {
+            if (service.process_db_id === processId) {
+                stopRuntimeService(service);
+                return c.json({ ok: true, service: toRuntimeServiceSummary(service) });
+            }
+        }
+        // Not in memory — just update DB
+        await db.query(`UPDATE processes SET status = 'stopped', stopped_at = CURRENT_TIMESTAMP WHERE id = $1`, [processId]);
+        return c.json({ ok: true });
+    });
+    app.post("/code/folders/:folderName/processes/detect", async (c) => {
+        const workspaceName = c.get("workspace");
+        const folderName = c.req.param("folderName");
+        const db = c.get("db");
+        const workspacePaths = (0, db_1.getWorkspacePaths)(workspaceName);
+        const folderPath = (0, node_path_1.join)(workspacePaths.codeDir, folderName);
+        const folderInfo = await (0, promises_1.stat)(folderPath).catch(() => null);
+        if (!folderInfo?.isDirectory()) {
+            throw new db_1.PragmaError("CODE_FOLDER_NOT_FOUND", 404, `Code folder not found: ${folderName}`);
+        }
+        // Run detection async
+        void detectProcessCommands(workspaceName, folderName, workspacePaths, db);
+        return c.json({ ok: true, detecting: true });
+    });
     // Read-only SSE event stream for a conversation thread.
     // Replays missed events using Last-Event-ID (the seq number),
     // then tails new events via the in-memory pub/sub.
@@ -1856,22 +2072,38 @@ LIMIT 1
             const processCwd = proc.cwd
                 ? await resolveTaskCommandCwd(runRoot, proc.cwd)
                 : runRoot;
+            const port = await getRandomFreePort();
+            const env = {
+                ...process.env,
+                PORT: String(port),
+                PRAGMA_WORKSPACE_NAME: workspaceName,
+                PRAGMA_TASK_ID: taskId,
+            };
+            // Rewrite command for frameworks that don't read PORT
+            let command = proc.command;
+            if (/\bvite\b|webpack-dev-server/.test(command)) {
+                command += ` --port ${port}`;
+            }
+            if (/\bvite\b|\bnext\b/.test(command)) {
+                command += ` --host 127.0.0.1`;
+            }
             const service = startRuntimeService({
                 workspaceName,
                 taskId,
                 label: proc.name,
-                command: proc.command,
+                command,
                 requestedCwd: proc.cwd || ".",
                 absoluteCwd: processCwd,
-                env: {
-                    ...process.env,
-                    PRAGMA_WORKSPACE_NAME: workspaceName,
-                    PRAGMA_TASK_ID: taskId,
-                },
+                env,
                 readyPattern: proc.ready_pattern,
-                port: proc.port,
+                port,
                 healthcheck: proc.healthcheck,
             });
+            // Track task-level processes in the processes table
+            const taskProcessId = `proc_${(0, node_crypto_1.randomUUID)().slice(0, 12)}`;
+            service.process_db_id = taskProcessId;
+            void db.query(`INSERT INTO processes (id, workspace, folder_name, label, command, cwd, type, status, pid, task_id, started_at)
+         VALUES ($1, $2, $3, $4, $5, $6, 'service', 'running', $7, $8, CURRENT_TIMESTAMP)`, [taskProcessId, workspaceName, "", proc.name, command, proc.cwd || ".", service.pid, taskId]);
             services[proc.name] = toRuntimeServiceSummary(service);
         }
         return c.json({ ok: true, services });
@@ -1879,35 +2111,33 @@ LIMIT 1
     app.post("/tasks/:taskId/testing/stop", async (c) => {
         const workspaceName = c.get("workspace");
         const taskId = c.req.param("taskId");
+        const db = c.get("db");
         const store = getWorkspaceServiceStore(workspaceName);
         for (const service of store.values()) {
             if (service.task_id === taskId) {
                 stopRuntimeService(service);
             }
         }
+        // Update task processes in DB
+        void db.query(`UPDATE processes SET status = 'stopped', stopped_at = CURRENT_TIMESTAMP WHERE task_id = $1 AND status = 'running'`, [taskId]);
         return c.json({ ok: true });
     });
     app.post("/tasks/:taskId/testing/proxy", (0, validators_1.validateJson)(schemas_1.testingProxyRequestSchema), async (c) => {
+        const workspaceName = c.get("workspace");
         const taskId = c.req.param("taskId");
         const body = c.req.valid("json");
-        const db = c.get("db");
-        const result = await db.query(`SELECT id, testing_config_json FROM tasks WHERE id = $1 LIMIT 1`, [taskId]);
-        const row = result.rows[0];
-        if (!row || !row.testing_config_json) {
-            throw new db_1.PragmaError("TASK_NOT_FOUND", 404, `Task or testing config not found: ${taskId}`);
-        }
-        let config;
-        try {
-            config = JSON.parse(row.testing_config_json);
-        }
-        catch {
-            throw new db_1.PragmaError("INVALID_TESTING_CONFIG", 400, "Testing config JSON is invalid.");
+        let servicePort = null;
+        const store = getWorkspaceServiceStore(workspaceName);
+        for (const service of store.values()) {
+            if (service.task_id === taskId && service.label === body.process_name && service.port) {
+                servicePort = service.port;
+                break;
+            }
         }
-        const proc = config.processes.find((p) => p.name === body.process_name);
-        if (!proc || !proc.port) {
-            throw new db_1.PragmaError("PROCESS_NOT_FOUND", 404, `Process "${body.process_name}" not found or has no port configured.`);
+        if (!servicePort) {
+            throw new db_1.PragmaError("PROCESS_NOT_FOUND", 404, `Process "${body.process_name}" not found or has no port assigned.`);
         }
-        const targetUrl = `http://localhost:${proc.port}${body.path}`;
+        const targetUrl = `http://127.0.0.1:${servicePort}${body.path}`;
         const startTime = Date.now();
         try {
             const fetchResponse = await fetch(targetUrl, {
@@ -2972,6 +3202,9 @@ VALUES ($1, $2, 'queued', $3, NULL, NULL, $4)
             throw new db_1.PragmaError("CLONE_CODE_REPO_FAILED", 400, errorMessage(error));
         }
         const folders = await listCodeFolders(paths.codeDir);
+        // Trigger process detection in the background
+        const db = c.get("db");
+        void detectProcessCommands(workspaceName, folderName, paths, db);
         return c.json({ ok: true, folder: { name: folderName }, folders }, 201);
     });
     app.post("/code/folders/pick-local", async (c) => {
@@ -3032,6 +3265,9 @@ VALUES ($1, $2, 'queued', $3, NULL, NULL, $4)
             throw new db_1.PragmaError("COPY_LOCAL_CODE_FAILED", 400, errorMessage(error));
         }
         const folders = await listCodeFolders(paths.codeDir);
+        // Trigger process detection in the background
+        const db = c.get("db");
+        void detectProcessCommands(workspaceName, folderName, paths, db);
         return c.json({ ok: true, folder: { name: folderName }, folders }, 201);
     });
     app.post("/code/folders/import", async (c) => {
@@ -4020,6 +4256,20 @@ VALUES ($1, $2, 'queued', $3, NULL, NULL, $4)
         console.log(`Pragma API listening on http://127.0.0.1:${info.port}`);
     });
     const shutdown = () => {
+        for (const [, store] of RUNTIME_SERVICES_BY_WORKSPACE) {
+            for (const service of store.values()) {
+                if (service.status === "running" || service.status === "ready") {
+                    try {
+                        if (service.pid && service.pid > 0) {
+                            process.kill(service.pid, "SIGTERM");
+                        }
+                    }
+                    catch {
+                        // Process may already be dead
+                    }
+                }
+            }
+        }
         server.close();
         void (0, db_1.closeOpenDatabases)().finally(() => {
             process.exit(0);
@@ -4028,6 +4278,85 @@ VALUES ($1, $2, 'queued', $3, NULL, NULL, $4)
     process.once("SIGINT", shutdown);
     process.once("SIGTERM", shutdown);
 }
+async function detectProcessCommands(workspaceName, folderName, workspacePaths, db) {
+    try {
+        const folderPath = (0, node_path_1.join)(workspacePaths.codeDir, folderName);
+        // Read key files to detect commands
+        const detectedProcesses = [];
+        // Check for package.json
+        try {
+            const pkgJson = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(folderPath, "package.json"), "utf8"));
+            const scripts = pkgJson.scripts || {};
+            for (const [name, cmd] of Object.entries(scripts)) {
+                if (typeof cmd !== "string")
+                    continue;
+                if (name === "dev" || name === "start" || name === "serve") {
+                    detectedProcesses.push({ label: `${name} (npm)`, command: `npm run ${name}`, cwd: ".", type: "service" });
+                }
+                else if (name === "build" || name === "test" || name === "lint") {
+                    detectedProcesses.push({ label: `${name} (npm)`, command: `npm run ${name}`, cwd: ".", type: "script" });
+                }
+            }
+        }
+        catch { /* no package.json */ }
+        // Check for Makefile
+        try {
+            const makefile = await (0, promises_1.readFile)((0, node_path_1.join)(folderPath, "Makefile"), "utf8");
+            const targets = makefile.match(/^([a-zA-Z_][a-zA-Z0-9_-]*):/gm);
+            if (targets) {
+                for (const target of targets.slice(0, 5)) {
+                    const name = target.replace(":", "");
+                    if (["run", "serve", "dev", "start"].includes(name)) {
+                        detectedProcesses.push({ label: `make ${name}`, command: `make ${name}`, cwd: ".", type: "service" });
+                    }
+                    else if (["build", "test", "lint", "clean"].includes(name)) {
+                        detectedProcesses.push({ label: `make ${name}`, command: `make ${name}`, cwd: ".", type: "script" });
+                    }
+                }
+            }
+        }
+        catch { /* no Makefile */ }
+        // Check for pyproject.toml
+        try {
+            await (0, promises_1.stat)((0, node_path_1.join)(folderPath, "pyproject.toml"));
+            detectedProcesses.push({ label: "Python Dev", command: "python -m uvicorn main:app --reload", cwd: ".", type: "service" });
+        }
+        catch { /* no pyproject.toml */ }
+        // Check for Cargo.toml
+        try {
+            await (0, promises_1.stat)((0, node_path_1.join)(folderPath, "Cargo.toml"));
+            detectedProcesses.push({ label: "Cargo Run", command: "cargo run", cwd: ".", type: "service" });
+            detectedProcesses.push({ label: "Cargo Build", command: "cargo build", cwd: ".", type: "script" });
+        }
+        catch { /* no Cargo.toml */ }
+        // Check for docker-compose
+        for (const dcFile of ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"]) {
+            try {
+                await (0, promises_1.stat)((0, node_path_1.join)(folderPath, dcFile));
+                detectedProcesses.push({ label: "Docker Compose Up", command: "docker compose up", cwd: ".", type: "service" });
+                break;
+            }
+            catch { /* no docker-compose */ }
+        }
+        if (detectedProcesses.length === 0)
+            return;
+        // Deduplicate: skip processes that already exist for this folder
+        const existing = await db.query(`SELECT command, cwd FROM processes WHERE workspace = $1 AND folder_name = $2`, [workspaceName, folderName]);
+        const existingKeys = new Set(existing.rows.map((r) => `${r.command}::${r.cwd}`));
+        for (const proc of detectedProcesses) {
+            const key = `${proc.command}::${proc.cwd}`;
+            if (existingKeys.has(key))
+                continue;
+            existingKeys.add(key);
+            const processId = `proc_${(0, node_crypto_1.randomUUID)().slice(0, 12)}`;
+            await db.query(`INSERT INTO processes (id, workspace, folder_name, label, command, cwd, type, status)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, 'stopped')`, [processId, workspaceName, folderName, proc.label, proc.command, proc.cwd, proc.type]);
+        }
+    }
+    catch (error) {
+        console.error(`[detect] Failed to detect processes for ${folderName}:`, error);
+    }
+}
 async function isDirectoryEmpty(path) {
     try {
         const entries = await (0, promises_1.readdir)(path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pragma-so",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Very minimal pragma-so CLI",
   "main": "dist/cli/index.js",
   "bin": {