feat: line-based process logs

CHANGELOG.md

@@ -28,6 +28,7 @@
 - Streamed `<think>` segments are stripped before partial replies are emitted.
 - System prompt now tags allowlisted owner numbers as the user identity to avoid mistaken “friend” assumptions.
 - LM Studio/Ollama replies now require <final> tags; streaming ignores content until <final> begins.
+- `process log` pagination is now line-based (omit `offset` to grab the last N lines).
 - UI perf: pause repeat animations when scenes are inactive (typing dots, onboarding glow, iOS status pulse), throttle voice overlay level updates, and reduce overlay focus churn.
 - Canvas defaults/A2UI auto-nav aligned; debug status overlay centered; redundant await removed in `CanvasManager`.
 - Gateway launchd loop fixed by removing redundant `kickstart -k`.

docs/background-process.md

@@ -15,7 +15,7 @@ Key parameters:
 - `command` (required)
 - `yieldMs` (default 20000): auto‑background after this delay
 - `background` (bool): background immediately
-- `timeout` (seconds): kill the process after this timeout
+- `timeout` (seconds, default 1800): kill the process after this timeout
 - `workdir`, `env`
 
 Behavior:
@@ -28,6 +28,11 @@ Environment overrides:
 - `PI_BASH_MAX_OUTPUT_CHARS`: in‑memory output cap (chars)
 - `PI_BASH_JOB_TTL_MS`: TTL for finished sessions (ms, bounded to 1m–3h)
 
+Config (preferred):
+- `agent.bash.backgroundMs` (default 20000)
+- `agent.bash.timeoutSec` (default 1800)
+- `agent.bash.cleanupMs` (default 1800000)
+
 ## process tool
 
 Actions:
@@ -43,6 +48,8 @@ Notes:
 - Only backgrounded sessions are listed/persisted in memory.
 - Sessions are lost on process restart (no disk persistence).
 - Session logs are only saved to chat history if you run `process poll/log` and the tool result is recorded.
+- `process list` includes a derived `name` (command verb + target) for quick scans.
+- `process log` uses line-based `offset`/`limit` (omit `offset` to grab the last N lines).
 
 ## Examples
 

docs/configuration.md

@@ -131,11 +131,21 @@ Controls the embedded agent runtime (provider/model/thinking/verbose/timeouts).
     timeoutSeconds: 600,
     mediaMaxMb: 5,
     heartbeatMinutes: 30,
+    bash: {
+      backgroundMs: 20000,
+      timeoutSec: 1800,
+      cleanupMs: 1800000
+    },
     contextTokens: 200000
   }
 }
 ```
 
+`agent.bash` configures background bash defaults:
+- `backgroundMs`: time before auto-background (ms, default 20000)
+- `timeoutSec`: auto-kill after this runtime (seconds, default 1800)
+- `cleanupMs`: how long to keep finished sessions in memory (ms, default 1800000)
+
 ### `models` (custom providers + base URLs)
 
 Clawdis uses the **pi-coding-agent** model catalog. You can add custom providers

docs/tools.md

@@ -20,7 +20,7 @@ Core parameters:
 - `command` (required)
 - `yieldMs` (auto-background after timeout, default 20000)
 - `background` (immediate background)
-- `timeout` (seconds; kills the process if exceeded)
+- `timeout` (seconds; kills the process if exceeded, default 1800)
 
 Notes:
 - Returns `status: "running"` with a `sessionId` when backgrounded.
@@ -34,7 +34,7 @@ Core actions:
 
 Notes:
 - `poll` returns new output and exit status when complete.
-- `log` supports `offset`/`limit` to page through output.
+- `log` supports line-based `offset`/`limit` (omit `offset` to grab the last N lines).
 
 ### `clawdis_browser`
 Control the dedicated clawd browser.
@@ -90,6 +90,15 @@ Notes:
 - `add` expects a full cron job object (same schema as `cron.add` RPC).
 - `update` uses `{ jobId, patch }`.
 
+### `clawdis_gateway`
+Restart the running Gateway process (in-place).
+
+Core actions:
+- `restart` (sends `SIGUSR1` to the current process; `clawdis gateway`/`gateway-daemon` restart in-place)
+
+Notes:
+- Use `delayMs` (defaults to 2000) to avoid interrupting an in-flight reply.
+
 ## Parameters (common)
 
 Gateway-backed tools (`clawdis_canvas`, `clawdis_nodes`, `clawdis_cron`):

src/agents/bash-process-registry.ts

@@ -9,7 +9,7 @@ function clampTtl(value: number | undefined) {
   return Math.min(Math.max(value, MIN_JOB_TTL_MS), MAX_JOB_TTL_MS);
 }
 
-const JOB_TTL_MS = clampTtl(
+let jobTtlMs = clampTtl(
   Number.parseInt(process.env.PI_BASH_JOB_TTL_MS ?? "", 10),
 );
 
@@ -163,14 +163,18 @@ export function clearFinished() {
 export function resetProcessRegistryForTests() {
   runningSessions.clear();
   finishedSessions.clear();
-  if (sweeper) {
-    clearInterval(sweeper);
-    sweeper = null;
-  }
+  stopSweeper();
+}
+
+export function setJobTtlMs(value?: number) {
+  if (value === undefined || Number.isNaN(value)) return;
+  jobTtlMs = clampTtl(value);
+  stopSweeper();
+  startSweeper();
 }
 
 function pruneFinishedSessions() {
-  const cutoff = Date.now() - JOB_TTL_MS;
+  const cutoff = Date.now() - jobTtlMs;
   for (const [id, session] of finishedSessions.entries()) {
     if (session.endedAt < cutoff) {
       finishedSessions.delete(id);
@@ -180,9 +184,12 @@ function pruneFinishedSessions() {
 
 function startSweeper() {
   if (sweeper) return;
-  sweeper = setInterval(
-    pruneFinishedSessions,
-    Math.max(30_000, JOB_TTL_MS / 6),
-  );
+  sweeper = setInterval(pruneFinishedSessions, Math.max(30_000, jobTtlMs / 6));
   sweeper.unref?.();
 }
+
+function stopSweeper() {
+  if (!sweeper) return;
+  clearInterval(sweeper);
+  sweeper = null;
+}

src/agents/bash-tools.test.ts

@@ -1,9 +1,30 @@
 import { beforeEach, describe, expect, it } from "vitest";
+import {
+  bashTool,
+  createBashTool,
+  createProcessTool,
+  processTool,
+} from "./bash-tools.js";
 import { resetProcessRegistryForTests } from "./bash-process-registry.js";
-import { bashTool, processTool } from "./bash-tools.js";
 
 const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 
+async function waitForCompletion(sessionId: string) {
+  let status = "running";
+  const deadline = Date.now() + 2000;
+  while (Date.now() < deadline && status === "running") {
+    const poll = await processTool.execute("call-wait", {
+      action: "poll",
+      sessionId,
+    });
+    status = (poll.details as { status: string }).status;
+    if (status === "running") {
+      await sleep(20);
+    }
+  }
+  return status;
+}
+
 beforeEach(() => {
   resetProcessRegistryForTests();
 });
@@ -54,4 +75,87 @@ describe("bash tool backgrounding", () => {
     ).sessions;
     expect(sessions.some((s) => s.sessionId === sessionId)).toBe(true);
   });
+
+  it("derives a session name from the command", async () => {
+    const result = await bashTool.execute("call1", {
+      command: "echo hello",
+      background: true,
+    });
+    const sessionId = (result.details as { sessionId: string }).sessionId;
+    await sleep(25);
+
+    const list = await processTool.execute("call2", { action: "list" });
+    const sessions = (
+      list.details as { sessions: Array<{ sessionId: string; name?: string }> }
+    ).sessions;
+    const entry = sessions.find((s) => s.sessionId === sessionId);
+    expect(entry?.name).toBe("echo hello");
+  });
+
+  it("uses default timeout when timeout is omitted", async () => {
+    const customBash = createBashTool({ timeoutSec: 1, backgroundMs: 10 });
+    const customProcess = createProcessTool();
+
+    const result = await customBash.execute("call1", {
+      command: "node -e \"setInterval(() => {}, 1000)\"",
+      background: true,
+    });
+
+    const sessionId = (result.details as { sessionId: string }).sessionId;
+    let status = "running";
+    const deadline = Date.now() + 5000;
+
+    while (Date.now() < deadline && status === "running") {
+      const poll = await customProcess.execute("call2", {
+        action: "poll",
+        sessionId,
+      });
+      status = (poll.details as { status: string }).status;
+      if (status === "running") {
+        await sleep(50);
+      }
+    }
+
+    expect(status).toBe("failed");
+  });
+
+  it("logs line-based slices and defaults to last lines", async () => {
+    const result = await bashTool.execute("call1", {
+      command:
+        "node -e \"console.log('one'); console.log('two'); console.log('three');\"",
+      background: true,
+    });
+    const sessionId = (result.details as { sessionId: string }).sessionId;
+
+    const status = await waitForCompletion(sessionId);
+
+    const log = await processTool.execute("call3", {
+      action: "log",
+      sessionId,
+      limit: 2,
+    });
+    const textBlock = log.content.find((c) => c.type === "text");
+    expect(textBlock?.text).toBe("two\nthree");
+    expect((log.details as { totalLines?: number }).totalLines).toBe(3);
+    expect(status).toBe("completed");
+  });
+
+  it("supports line offsets for log slices", async () => {
+    const result = await bashTool.execute("call1", {
+      command:
+        "node -e \"console.log('alpha'); console.log('beta'); console.log('gamma');\"",
+      background: true,
+    });
+    const sessionId = (result.details as { sessionId: string }).sessionId;
+    await waitForCompletion(sessionId);
+
+    const log = await processTool.execute("call2", {
+      action: "log",
+      sessionId,
+      offset: 1,
+      limit: 1,
+    });
+    const textBlock = log.content.find((c) => c.type === "text");
+    expect(textBlock?.text).toBe("beta");
+  });
 });

src/agents/pi-embedded-runner.ts

@@ -325,7 +325,9 @@ export async function runEmbeddedPiAgent(params: {
         await loadWorkspaceBootstrapFiles(resolvedWorkspace);
       const contextFiles = buildBootstrapContextFiles(bootstrapFiles);
       const promptSkills = resolvePromptSkills(skillsSnapshot, skillEntries);
-      const tools = createClawdisCodingTools();
+      const tools = createClawdisCodingTools({
+        bash: params.config?.agent?.bash,
+      });
       const machineName = await getMachineDisplayName();
       const runtimeInfo = {
         host: machineName,

src/agents/pi-tools.test.ts

@@ -32,6 +32,9 @@ describe("createClawdisCodingTools", () => {
         anyOf?: Array<{ properties?: Record<string, unknown> }>;
         properties?: Record<string, unknown>;
       };
+      if (!Array.isArray(parameters.anyOf) || parameters.anyOf.length === 0) {
+        continue;
+      }
       const actionValues = new Set<string>();
       for (const variant of parameters.anyOf ?? []) {
         const action = variant?.properties?.action as
@@ -45,6 +48,9 @@ describe("createClawdisCodingTools", () => {
         }
       }
 
+      if (actionValues.size <= 1) {
+        continue;
+      }
       const mergedAction = parameters.properties?.action as
         | { const?: unknown; enum?: unknown[] }
         | undefined;

src/agents/pi-tools.ts

@@ -4,7 +4,12 @@ import { type TSchema, Type } from "@sinclair/typebox";
 
 import { detectMime } from "../media/mime.js";
 import { startWebLoginWithQr, waitForWebLogin } from "../web/login-qr.js";
-import { bashTool, processTool } from "./bash-tools.js";
+import {
+  type BashToolDefaults,
+  type ProcessToolDefaults,
+  createBashTool,
+  createProcessTool,
+} from "./bash-tools.js";
 import { createClawdisTools } from "./clawdis-tools.js";
 import { sanitizeToolResultImages } from "./tool-images.js";
 
@@ -288,18 +293,24 @@ function createClawdisReadTool(base: AnyAgentTool): AnyAgentTool {
   };
 }
 
-export function createClawdisCodingTools(): AnyAgentTool[] {
+export function createClawdisCodingTools(options?: {
+  bash?: BashToolDefaults & ProcessToolDefaults;
+}): AnyAgentTool[] {
+  const bashToolName = "bash";
   const base = (codingTools as unknown as AnyAgentTool[]).flatMap((tool) => {
     if (tool.name === readTool.name) return [createClawdisReadTool(tool)];
-    if (tool.name === bashTool.name) return [];
+    if (tool.name === bashToolName) return [];
     return [tool as AnyAgentTool];
   });
-  const tools: AnyAgentTool[] = [
+  const bashTool = createBashTool(options?.bash);
+  const processTool = createProcessTool({
+    cleanupMs: options?.bash?.cleanupMs,
+  });
+  return [
     ...base,
-    bashTool as unknown as AnyAgentTool,
-    processTool as unknown as AnyAgentTool,
+    bashTool,
+    processTool,
     createWhatsAppLoginTool(),
     ...createClawdisTools(),
-  ];
-  return tools.map(normalizeToolParameters);
+  ].map(normalizeToolParameters);
 }

src/config/config.ts

@@ -325,6 +325,15 @@ export type ClawdisConfig = {
     typingIntervalSeconds?: number;
     /** Periodic background heartbeat runs (minutes). 0 disables. */
     heartbeatMinutes?: number;
+    /** Bash tool defaults. */
+    bash?: {
+      /** Default time (ms) before a bash command auto-backgrounds. */
+      backgroundMs?: number;
+      /** Default timeout (seconds) before auto-killing bash commands. */
+      timeoutSec?: number;
+      /** How long to keep finished sessions in memory (ms). */
+      cleanupMs?: number;
+    };
   };
   routing?: RoutingConfig;
   messages?: MessagesConfig;
@@ -573,6 +582,13 @@ const ClawdisSchema = z.object({
       mediaMaxMb: z.number().positive().optional(),
       typingIntervalSeconds: z.number().int().positive().optional(),
       heartbeatMinutes: z.number().nonnegative().optional(),
+      bash: z
+        .object({
+          backgroundMs: z.number().int().positive().optional(),
+          timeoutSec: z.number().int().positive().optional(),
+          cleanupMs: z.number().int().positive().optional(),
+        })
+        .optional(),
     })
     .optional(),
   routing: RoutingSchema,