@openparachute/agent 0.1.0

package/scripts/chat.ts

@@ -0,0 +1,101 @@
+/**
+ * nc — chat with your Paraclaw agent from the terminal.
+ *
+ * Usage:
+ *   pnpm run chat <message...>
+ *
+ * Sends the message through the CLI channel (Unix socket) to the wired agent.
+ * Reads replies until the stream goes quiet, then exits.
+ *
+ * Preconditions: Paraclaw host service running, an agent group wired to
+ * `cli/local` via `/init-first-agent` or `/manage-channels`.
+ */
+import net from 'net';
+import path from 'path';
+
+import { DATA_DIR } from '../src/config.js';
+
+const SILENCE_MS = 2000; // exit after this much quiet time following the first reply
+const TOTAL_TIMEOUT_MS = 120_000; // hard stop
+
+function socketPath(): string {
+  return path.join(DATA_DIR, 'cli.sock');
+}
+
+function main(): void {
+  const words = process.argv.slice(2);
+  if (words.length === 0) {
+    console.error('usage: pnpm run chat <message...>');
+    process.exit(1);
+  }
+  const text = words.join(' ');
+
+  const socket = net.connect(socketPath());
+
+  socket.on('error', (err) => {
+    const e = err as NodeJS.ErrnoException;
+    if (e.code === 'ENOENT' || e.code === 'ECONNREFUSED') {
+      console.error(`Paraclaw daemon not reachable at ${socketPath()}.`);
+      console.error('Start the service (launchctl/systemd) before running nc.');
+    } else {
+      console.error('CLI socket error:', err);
+    }
+    process.exit(2);
+  });
+
+  let firstReplySeen = false;
+  let silenceTimer: NodeJS.Timeout | null = null;
+  let hardTimer: NodeJS.Timeout | null = null;
+
+  function scheduleExit(): void {
+    if (silenceTimer) clearTimeout(silenceTimer);
+    silenceTimer = setTimeout(() => {
+      socket.end();
+      process.exit(0);
+    }, SILENCE_MS);
+  }
+
+  socket.on('connect', () => {
+    socket.write(JSON.stringify({ text }) + '\n');
+    hardTimer = setTimeout(() => {
+      if (!firstReplySeen) {
+        console.error(`timeout: no reply in ${TOTAL_TIMEOUT_MS}ms`);
+        socket.end();
+        process.exit(3);
+      }
+    }, TOTAL_TIMEOUT_MS);
+  });
+
+  let buffer = '';
+  socket.on('data', (chunk) => {
+    buffer += chunk.toString('utf8');
+    let idx: number;
+    while ((idx = buffer.indexOf('\n')) >= 0) {
+      const line = buffer.slice(0, idx).trim();
+      buffer = buffer.slice(idx + 1);
+      if (!line) continue;
+      try {
+        const msg = JSON.parse(line);
+        if (typeof msg.text === 'string') {
+          process.stdout.write(msg.text + '\n');
+          firstReplySeen = true;
+          if (hardTimer) {
+            clearTimeout(hardTimer);
+            hardTimer = null;
+          }
+          scheduleExit();
+        }
+      } catch {
+        // Ignore non-JSON lines — forward compatibility.
+      }
+    }
+  });
+
+  socket.on('close', () => {
+    if (silenceTimer) clearTimeout(silenceTimer);
+    if (hardTimer) clearTimeout(hardTimer);
+    process.exit(firstReplySeen ? 0 : 3);
+  });
+}
+
+main();

package/scripts/cleanup-sessions.sh

@@ -0,0 +1,150 @@
+#!/bin/bash
+#
+# Prune stale session artifacts (JSONLs, debug logs, todos, telemetry, group logs).
+# Safe to run while Paraclaw is live — active sessions are read from the DB.
+#
+# Usage:  ./scripts/cleanup-sessions.sh [--dry-run]
+#
+# Retention:
+#   Session JSONLs + tool-results:  7 days  (active session always kept)
+#   Debug logs:                     3 days
+#   Todo files:                     3 days
+#   Telemetry:                      7 days
+#   Group logs:                     7 days
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
+
+STORE_DB="$PROJECT_ROOT/store/messages.db"
+SESSIONS_DIR="$PROJECT_ROOT/data/sessions"
+GROUPS_DIR="$PROJECT_ROOT/groups"
+
+DRY_RUN=false
+[[ "${1:-}" == "--dry-run" ]] && DRY_RUN=true
+
+TOTAL_FREED=0
+
+log() { echo "[cleanup] $*"; }
+
+remove() {
+  local target="$1"
+  if $DRY_RUN; then
+    if [ -d "$target" ]; then
+      size=$(du -sk "$target" 2>/dev/null | cut -f1)
+    else
+      size=$(wc -c < "$target" 2>/dev/null || echo 0)
+      size=$((size / 1024))
+    fi
+    TOTAL_FREED=$((TOTAL_FREED + size))
+    log "would remove: $target (${size}K)"
+  else
+    if [ -d "$target" ]; then
+      size=$(du -sk "$target" 2>/dev/null | cut -f1)
+      rm -rf "$target"
+    else
+      size=$(wc -c < "$target" 2>/dev/null || echo 0)
+      size=$((size / 1024))
+      rm -f "$target"
+    fi
+    TOTAL_FREED=$((TOTAL_FREED + size))
+  fi
+}
+
+# --- Collect active session IDs from the database ---
+
+if [ ! -f "$STORE_DB" ]; then
+  log "ERROR: database not found at $STORE_DB"
+  exit 1
+fi
+
+ACTIVE_IDS=$(sqlite3 "$STORE_DB" "SELECT session_id FROM sessions;" 2>/dev/null || true)
+
+is_active() {
+  echo "$ACTIVE_IDS" | grep -qF "$1"
+}
+
+# --- Prune session JSONLs and tool-results dirs ---
+
+for group_dir in "$SESSIONS_DIR"/*/; do
+  [ -d "$group_dir" ] || continue
+  jsonl_dir="$group_dir/.claude/projects/-workspace-group"
+  [ -d "$jsonl_dir" ] || continue
+
+  for jsonl in "$jsonl_dir"/*.jsonl; do
+    [ -f "$jsonl" ] || continue
+    id=$(basename "$jsonl" .jsonl)
+
+    # Never delete the active session
+    if is_active "$id"; then
+      continue
+    fi
+
+    # Only delete if older than 7 days
+    if [ -n "$(find "$jsonl" -mtime +7 2>/dev/null)" ]; then
+      remove "$jsonl"
+      # Remove matching tool-results directory
+      [ -d "$jsonl_dir/$id" ] && remove "$jsonl_dir/$id"
+    fi
+  done
+done
+
+# --- Prune debug logs (>3 days, skip files named after active sessions) ---
+
+for group_dir in "$SESSIONS_DIR"/*/; do
+  debug_dir="$group_dir/.claude/debug"
+  [ -d "$debug_dir" ] || continue
+  while IFS= read -r -d '' f; do
+    fname=$(basename "$f" .txt)
+    is_active "$fname" && continue
+    remove "$f"
+  done < <(find "$debug_dir" -type f -mtime +3 ! -name "latest" -print0 2>/dev/null)
+done
+
+# --- Prune todo files (>3 days, skip files named after active sessions) ---
+
+for group_dir in "$SESSIONS_DIR"/*/; do
+  todos_dir="$group_dir/.claude/todos"
+  [ -d "$todos_dir" ] || continue
+  while IFS= read -r -d '' f; do
+    fname=$(basename "$f" .json)
+    # Todo filenames are like {session_id}-agent-{session_id}.json
+    for aid in $ACTIVE_IDS; do
+      if [[ "$fname" == *"$aid"* ]]; then
+        continue 2
+      fi
+    done
+    remove "$f"
+  done < <(find "$todos_dir" -type f -mtime +3 -print0 2>/dev/null)
+done
+
+# --- Prune telemetry (>7 days, skip files named after active sessions) ---
+
+for group_dir in "$SESSIONS_DIR"/*/; do
+  telem_dir="$group_dir/.claude/telemetry"
+  [ -d "$telem_dir" ] || continue
+  while IFS= read -r -d '' f; do
+    fname=$(basename "$f")
+    for aid in $ACTIVE_IDS; do
+      if [[ "$fname" == *"$aid"* ]]; then
+        continue 2
+      fi
+    done
+    remove "$f"
+  done < <(find "$telem_dir" -type f -mtime +7 -print0 2>/dev/null)
+done
+
+# --- Prune group logs (>7 days) ---
+
+while IFS= read -r -d '' f; do
+  remove "$f"
+done < <(find "$GROUPS_DIR"/*/logs -type f -mtime +7 -print0 2>/dev/null)
+
+# --- Summary ---
+
+if $DRY_RUN; then
+  log "DRY RUN complete — would free ~${TOTAL_FREED}K"
+else
+  log "Done — freed ~${TOTAL_FREED}K"
+fi

package/scripts/init-cli-agent.ts

@@ -0,0 +1,171 @@
+/**
+ * Initialize the scratch CLI agent used during `/new-setup`.
+ *
+ * Creates the synthetic `cli:local` user, grants owner role if no owner
+ * exists yet, builds an agent group with a minimal CLAUDE.md, and wires it
+ * to the CLI messaging group so `pnpm run chat` works immediately.
+ *
+ * No welcome is staged — the operator's first `pnpm run chat` is the
+ * natural wake, and the agent introduces itself on first contact per its
+ * CLAUDE.md.
+ *
+ * Runs alongside the service (WAL-mode sqlite) — does NOT initialize
+ * channel adapters, so there's no Gateway conflict.
+ *
+ * Usage:
+ *   pnpm exec tsx scripts/init-cli-agent.ts \
+ *     --display-name "Gavriel" \
+ *     [--agent-name "Andy"]
+ */
+import path from 'path';
+
+import { CENTRAL_DB_PATH } from '../src/config.js';
+import { createAgentGroup, getAgentGroupByFolder } from '../src/db/agent-groups.js';
+import { initDb, migrateCentralDbLocation } from '../src/db/connection.js';
+import {
+  createMessagingGroup,
+  createMessagingGroupAgent,
+  getMessagingGroupAgentByPair,
+  getMessagingGroupByPlatform,
+} from '../src/db/messaging-groups.js';
+import { runMigrations } from '../src/db/migrations/index.js';
+import { normalizeName } from '../src/modules/agent-to-agent/db/agent-destinations.js';
+import { upsertUser } from '../src/modules/permissions/db/users.js';
+import { initGroupFilesystem } from '../src/group-init.js';
+import type { AgentGroup, MessagingGroup } from '../src/types.js';
+
+const CLI_CHANNEL = 'cli';
+const CLI_PLATFORM_ID = 'local';
+const CLI_SYNTHETIC_USER_ID = `${CLI_CHANNEL}:${CLI_PLATFORM_ID}`;
+
+interface Args {
+  displayName: string;
+  agentName: string;
+}
+
+function parseArgs(argv: string[]): Args {
+  let displayName: string | undefined;
+  let agentName: string | undefined;
+  for (let i = 0; i < argv.length; i++) {
+    const key = argv[i];
+    const val = argv[i + 1];
+    if (key === '--display-name') {
+      displayName = val;
+      i++;
+    } else if (key === '--agent-name') {
+      agentName = val;
+      i++;
+    }
+  }
+
+  if (!displayName) {
+    console.error('Missing required arg: --display-name');
+    console.error('See scripts/init-cli-agent.ts header for usage.');
+    process.exit(2);
+  }
+
+  return {
+    displayName,
+    agentName: agentName?.trim() || displayName,
+  };
+}
+
+function generateId(prefix: string): string {
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+async function main(): Promise<void> {
+  const args = parseArgs(process.argv.slice(2));
+
+  migrateCentralDbLocation();
+  const db = initDb(CENTRAL_DB_PATH);
+  runMigrations(db);
+
+  const now = new Date().toISOString();
+
+  // 1. Synthetic CLI user + owner grant if none exists.
+  upsertUser({
+    id: CLI_SYNTHETIC_USER_ID,
+    kind: CLI_CHANNEL,
+    display_name: args.displayName,
+    created_at: now,
+  });
+
+  // Owner grant deferred to init-first-agent when the real channel user is
+  // wired — cli:local is a scratch identity, not the operator.
+  const promotedToOwner = false;
+
+  // 2. Agent group + filesystem.
+  const folder = `cli-with-${normalizeName(args.displayName)}`;
+  let ag: AgentGroup | undefined = getAgentGroupByFolder(folder);
+  if (!ag) {
+    const agId = generateId('ag');
+    createAgentGroup({
+      id: agId,
+      name: args.agentName,
+      folder,
+      agent_provider: null,
+      created_at: now,
+    });
+    ag = getAgentGroupByFolder(folder)!;
+    console.log(`Created agent group: ${ag.id} (${folder})`);
+  } else {
+    console.log(`Reusing agent group: ${ag.id} (${folder})`);
+  }
+  initGroupFilesystem(ag, {
+    instructions:
+      `# ${args.agentName}\n\n` +
+      `You are ${args.agentName}, a personal Paraclaw agent for ${args.displayName}. ` +
+      'When the user first reaches out, introduce yourself briefly and invite them to chat. Keep replies concise.',
+  });
+
+  // 3. CLI messaging group + wiring.
+  let cliMg: MessagingGroup | undefined = getMessagingGroupByPlatform(CLI_CHANNEL, CLI_PLATFORM_ID);
+  if (!cliMg) {
+    cliMg = {
+      id: generateId('mg'),
+      channel_type: CLI_CHANNEL,
+      platform_id: CLI_PLATFORM_ID,
+      name: 'Local CLI',
+      is_group: 0,
+      unknown_sender_policy: 'public',
+      created_at: now,
+    };
+    createMessagingGroup(cliMg);
+    console.log(`Created CLI messaging group: ${cliMg.id}`);
+  }
+
+  const existing = getMessagingGroupAgentByPair(cliMg.id, ag.id);
+  if (!existing) {
+    createMessagingGroupAgent({
+      id: generateId('mga'),
+      messaging_group_id: cliMg.id,
+      agent_group_id: ag.id,
+      engage_mode: 'pattern',
+      engage_pattern: '.',
+      sender_scope: 'all',
+      ignored_message_policy: 'drop',
+      session_mode: 'shared',
+      priority: 0,
+      created_at: now,
+    });
+    console.log(`Wired cli: ${cliMg.id} -> ${ag.id}`);
+  } else {
+    console.log(`Wiring already exists: ${existing.id}`);
+  }
+
+  console.log('');
+  console.log('Init complete.');
+  console.log(
+    `  owner:   ${CLI_SYNTHETIC_USER_ID}${promotedToOwner ? ' (promoted on first owner)' : ''}`,
+  );
+  console.log(`  agent:   ${ag.name} [${ag.id}] @ groups/${folder}`);
+  console.log(`  channel: cli/${CLI_PLATFORM_ID}`);
+  console.log('');
+  console.log('Run `pnpm run chat hi` to talk to your agent.');
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});