tryharness 0.3.0 → 0.4.0

package/lib/paths.mjs

@@ -0,0 +1,35 @@
+import os from "node:os";
+import path from "node:path";
+
+// HARNESS_HOME is deliberately task-specific. It also makes every filesystem-affecting
+// command testable without touching a developer's real ~/.harness installation.
+export const harnessHome = process.env.HARNESS_HOME
+  ? path.resolve(process.env.HARNESS_HOME)
+  : path.join(os.homedir(), ".harness");
+
+export const paths = {
+  home: harnessHome,
+  config: path.join(harnessHome, "config.json"),
+  database: path.join(harnessHome, "harness.db"),
+  status: path.join(harnessHome, "daemon-status.json"),
+  socket: process.platform === "win32" ? "\\\\.\\pipe\\tryharness-daemon" : path.join(harnessHome, "daemon.sock"),
+  log: path.join(harnessHome, "daemon.log"),
+  runtime: path.join(harnessHome, "runtime"),
+  legacyBridgeConfig: path.join(harnessHome, "bridge.json"),
+  legacySpool: path.join(harnessHome, "pending-sessions.json"),
+};
+
+export function historyRoots(agent) {
+  if (agent === "claude-code") return [process.env.HARNESS_CLAUDE_HISTORY_ROOT || path.join(os.homedir(), ".claude", "projects")];
+  if (agent === "codex") return [process.env.HARNESS_CODEX_HISTORY_ROOT || path.join(os.homedir(), ".codex", "sessions")];
+  if (agent === "pi") {
+    return Array.from(new Set([
+      process.env.HARNESS_PI_HISTORY_ROOT,
+      process.env.PI_CODING_AGENT_SESSION_DIR,
+      process.env.PI_CODING_AGENT_DIR ? path.join(process.env.PI_CODING_AGENT_DIR, "sessions") : null,
+      path.join(os.homedir(), ".pi", "agent", "sessions"),
+      path.join(os.homedir(), ".local", "share", "pi-coding-agent", "sessions"),
+    ].filter(Boolean)));
+  }
+  return [];
+}

package/lib/runner.mjs

@@ -0,0 +1,89 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+
+const running = new Set();
+
+function workingDirectory(requested) {
+  const home = os.homedir();
+  const resolved = !requested ? home : requested === "~" ? home : requested.startsWith("~/") ? path.join(home, requested.slice(2)) : requested;
+  return fs.existsSync(resolved) ? resolved : home;
+}
+
+export function runAgentTask(task, emit) {
+  if (running.has(task.agent)) {
+    emit("failed", `A ${task.agent} task is already running on this machine.`);
+    return;
+  }
+  running.add(task.agent);
+  emit("accepted");
+  const cwd = workingDirectory(task.cwd);
+  let child;
+  try {
+    if (task.agent === "claude-code") {
+      child = spawn("claude", ["-p", task.brief, "--output-format", "stream-json", "--verbose", "--permission-mode", "acceptEdits"], { cwd });
+    } else if (task.agent === "codex") {
+      const help = spawnSync("codex", ["exec", "--help"], { encoding: "utf8" });
+      const args = ["exec", "--json", "--sandbox", "workspace-write", "--skip-git-repo-check"];
+      if (String(help.stdout || "").includes("--approve-for-me")) args.push("--approve-for-me");
+      args.push("-");
+      child = spawn("codex", args, { cwd });
+      child.stdin.end(task.brief);
+    } else if (task.agent === "pi") {
+      child = spawn("pi", ["--mode", "json", "-p", task.brief], { cwd });
+    } else if (task.agent === "opencode") {
+      child = spawn("opencode", ["run", "--format", "json", "--title", task.title, "--", task.brief], { cwd });
+    } else {
+      running.delete(task.agent);
+      emit("failed", `Unsupported agent: ${task.agent}`);
+      return;
+    }
+  } catch (error) {
+    running.delete(task.agent);
+    emit("failed", `Could not start ${task.agent}: ${error.message}`);
+    return;
+  }
+
+  let resultText = "";
+  let tail = "";
+  let buffer = "";
+  let sessionReported = false;
+  child.stdout?.on("data", (chunk) => {
+    buffer += String(chunk);
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      tail = (tail + "\n" + line).slice(-4_000);
+      let event;
+      try { event = JSON.parse(line); } catch { continue; }
+      const sessionId = event.session_id || event.sessionId || event.sessionID || event.thread_id || event.thread?.id || event.properties?.sessionID;
+      if (!sessionReported && typeof sessionId === "string" && sessionId) {
+        sessionReported = true;
+        emit("session", sessionId, { cwd });
+      }
+      if (event.type === "result" && typeof event.result === "string") resultText = event.result;
+      if (event.type === "item.completed" && event.item?.type === "agent_message" && typeof event.item.text === "string") resultText = event.item.text;
+      if (["text", "message.part.updated"].includes(event.type) && typeof event.part?.text === "string") resultText = event.part.text;
+      const progress = event.type === "assistant" && Array.isArray(event.message?.content)
+        ? event.message.content.filter((block) => block.type === "text").map((block) => block.text).join(" ")
+        : event.type === "message_update" && typeof event.text === "string"
+          ? event.text
+          : event.type === "item.completed" && event.item?.type && event.item.type !== "agent_message"
+            ? event.item.type + (event.item.command ? ": " + event.item.command : "")
+            : typeof event.part?.text === "string" ? event.part.text : null;
+      if (progress?.trim()) emit("progress", progress.trim().slice(0, 200));
+    }
+  });
+  child.stderr?.on("data", (chunk) => { tail = (tail + "\n" + String(chunk)).slice(-4_000); });
+  child.on("close", (code) => {
+    running.delete(task.agent);
+    if (code === 0) emit("done", (resultText || "The run finished; check the repository for its changes.").slice(0, 20_000));
+    else emit("failed", (`${task.agent} exited with code ${code}.\n${tail}`).slice(0, 4_000));
+  });
+  child.on("error", (error) => {
+    running.delete(task.agent);
+    emit("failed", `Could not start ${task.agent}: ${error.message}`);
+  });
+}

package/lib/runtime-install.mjs

@@ -0,0 +1,75 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { ensureDir, readJson, writeJsonAtomic } from "./files.mjs";
+import { paths } from "./paths.mjs";
+
+function packageDirectory(packageJson) {
+  return path.dirname(packageJson);
+}
+
+function dependencyTarget(root, name) {
+  return path.join(root, "node_modules", ...name.split("/"));
+}
+
+function copyDependencyClosure(sourceRoot, releaseRoot, roots) {
+  const queue = roots.map((name) => ({ name, require: createRequire(path.join(sourceRoot, "package.json")) }));
+  const copied = new Set();
+  while (queue.length) {
+    const item = queue.shift();
+    if (copied.has(item.name)) continue;
+    let packageJson;
+    try { packageJson = item.require.resolve(`${item.name}/package.json`); }
+    catch {
+      // Packages with restrictive exports still resolve their main file. Walk upward to
+      // the package.json whose name matches the requested dependency.
+      let current = path.dirname(item.require.resolve(item.name));
+      while (current !== path.dirname(current)) {
+        const candidate = path.join(current, "package.json");
+        if (readJson(candidate, {}).name === item.name) { packageJson = candidate; break; }
+        current = path.dirname(current);
+      }
+    }
+    if (!packageJson) throw new Error(`could not package runtime dependency ${item.name}`);
+    const source = packageDirectory(packageJson);
+    const target = dependencyTarget(releaseRoot, item.name);
+    ensureDir(path.dirname(target));
+    fs.cpSync(source, target, { recursive: true, force: true });
+    copied.add(item.name);
+    const metadata = readJson(packageJson, {});
+    const nestedRequire = createRequire(packageJson);
+    for (const name of Object.keys({ ...(metadata.dependencies || {}), ...(metadata.optionalDependencies || {}) })) {
+      try {
+        nestedRequire.resolve(name);
+        queue.push({ name, require: nestedRequire });
+      } catch {}
+    }
+  }
+}
+
+export function installRuntime({ sourceRoot, version }) {
+  const release = path.join(paths.runtime, "releases", version);
+  const marker = path.join(release, ".ready");
+  if (!fs.existsSync(marker)) {
+    const staging = `${release}.staging-${process.pid}`;
+    fs.rmSync(staging, { recursive: true, force: true });
+    ensureDir(staging);
+    for (const entry of ["cli.mjs", "package.json", "README.md", "lib", "assets"]) {
+      const source = path.join(sourceRoot, entry);
+      if (!fs.existsSync(source)) continue;
+      fs.cpSync(source, path.join(staging, entry), { recursive: true, force: true });
+    }
+    copyDependencyClosure(sourceRoot, staging, ["better-sqlite3", "ws"]);
+    fs.writeFileSync(path.join(staging, ".ready"), version + "\n", { mode: 0o600 });
+    ensureDir(path.dirname(release));
+    fs.rmSync(release, { recursive: true, force: true });
+    fs.renameSync(staging, release);
+  }
+  writeJsonAtomic(path.join(paths.runtime, "current.json"), { version, path: release });
+  return release;
+}
+
+export function currentRuntime() {
+  const current = readJson(path.join(paths.runtime, "current.json"), {});
+  return typeof current.path === "string" && fs.existsSync(current.path) ? current.path : null;
+}

package/lib/service.mjs

@@ -0,0 +1,99 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { resolveCommand, run } from "./commands.mjs";
+import { ensureDir } from "./files.mjs";
+import { paths } from "./paths.mjs";
+
+const LABEL = "ai.tryharness.daemon";
+
+function xml(value) {
+  return String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+
+function servicePath() {
+  if (process.platform === "darwin") return path.join(os.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
+  if (process.platform === "linux") return path.join(os.homedir(), ".config", "systemd", "user", "tryharness-daemon.service");
+  return null;
+}
+
+function agentPath() {
+  const dirs = new Set([path.dirname(process.execPath), "/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"]);
+  for (const command of ["claude", "codex", "pi", "opencode"]) {
+    const found = resolveCommand(command);
+    if (found) dirs.add(path.dirname(found));
+  }
+  return [...dirs].join(path.delimiter);
+}
+
+function retireLegacyBridge() {
+  if (process.platform === "darwin") {
+    const legacy = path.join(os.homedir(), "Library", "LaunchAgents", "ai.tryharness.bridge.plist");
+    if (!fs.existsSync(legacy)) return;
+    run("launchctl", ["unload", legacy]);
+    try { fs.renameSync(legacy, legacy + ".retired"); } catch {}
+  } else if (process.platform === "linux") {
+    const legacy = path.join(os.homedir(), ".config", "systemd", "user", "tryharness-bridge.service");
+    if (!fs.existsSync(legacy)) return;
+    run("systemctl", ["--user", "disable", "--now", "tryharness-bridge.service"]);
+    try { fs.renameSync(legacy, legacy + ".retired"); } catch {}
+  }
+}
+
+export function installService({ runtimeRoot, nodePath = process.execPath }) {
+  ensureDir(paths.home);
+  retireLegacyBridge();
+  const entry = path.join(runtimeRoot, "cli.mjs");
+  const envPath = agentPath();
+  if (process.platform === "darwin") {
+    const plist = servicePath();
+    ensureDir(path.dirname(plist));
+    fs.writeFileSync(plist, `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>Label</key><string>${LABEL}</string>
+  <key>ProgramArguments</key><array><string>${xml(nodePath)}</string><string>${xml(entry)}</string><string>daemon</string></array>
+  <key>EnvironmentVariables</key><dict><key>PATH</key><string>${xml(envPath)}</string></dict>
+  <key>RunAtLoad</key><true/><key>KeepAlive</key><true/><key>ThrottleInterval</key><integer>5</integer>
+  <key>StandardOutPath</key><string>${xml(paths.log)}</string><key>StandardErrorPath</key><string>${xml(paths.log)}</string>
+</dict></plist>\n`, { mode: 0o600 });
+    const domain = `gui/${process.getuid()}`;
+    run("launchctl", ["bootout", domain, plist]);
+    const started = run("launchctl", ["bootstrap", domain, plist]);
+    if (!started.ok) throw new Error(`could not start Harness daemon with launchd: ${started.stderr || started.error}`);
+    run("launchctl", ["kickstart", "-k", `${domain}/${LABEL}`]);
+    return { manager: "launchd", file: plist };
+  }
+  if (process.platform === "linux") {
+    const unit = servicePath();
+    ensureDir(path.dirname(unit));
+    fs.writeFileSync(unit, `[Unit]\nDescription=Harness local daemon\nAfter=network-online.target\n\n[Service]\nExecStart=${JSON.stringify(nodePath)} ${JSON.stringify(entry)} daemon\nEnvironment=PATH=${envPath}\nRestart=always\nRestartSec=5\nStandardOutput=append:${paths.log}\nStandardError=append:${paths.log}\n\n[Install]\nWantedBy=default.target\n`, { mode: 0o600 });
+    const reload = run("systemctl", ["--user", "daemon-reload"]);
+    const started = run("systemctl", ["--user", "enable", "--now", "tryharness-daemon.service"]);
+    if (!reload.ok || !started.ok) throw new Error(`could not start Harness daemon with systemd: ${started.stderr || reload.stderr}`);
+    return { manager: "systemd", file: unit };
+  }
+  // Windows and other Node platforms still get a ready daemon immediately. `doctor`
+  // reports that login persistence is unavailable rather than pretending it was set.
+  const child = spawn(nodePath, [entry, "daemon"], { detached: true, stdio: "ignore", env: { ...process.env, PATH: envPath } });
+  child.unref();
+  return { manager: "detached", file: null };
+}
+
+export function uninstallService() {
+  const file = servicePath();
+  if (process.platform === "darwin" && file) {
+    run("launchctl", ["bootout", `gui/${process.getuid()}`, file]);
+    try { fs.unlinkSync(file); } catch {}
+  } else if (process.platform === "linux" && file) {
+    run("systemctl", ["--user", "disable", "--now", "tryharness-daemon.service"]);
+    try { fs.unlinkSync(file); } catch {}
+    run("systemctl", ["--user", "daemon-reload"]);
+  }
+}
+
+export function serviceInfo() {
+  const file = servicePath();
+  return { manager: process.platform === "darwin" ? "launchd" : process.platform === "linux" ? "systemd" : "detached", installed: Boolean(file && fs.existsSync(file)), file };
+}

package/lib/store.mjs

@@ -0,0 +1,160 @@
+import Database from "better-sqlite3";
+import { parseSession } from "./parsers.mjs";
+
+const SCHEMA_VERSION = 2;
+
+export function openStore(file) {
+  const db = new Database(file);
+  db.pragma("journal_mode = WAL");
+  db.pragma("synchronous = NORMAL");
+  db.pragma("busy_timeout = 5000");
+  db.exec(`
+    create table if not exists schema_info (version integer not null);
+    insert into schema_info(version) select ${SCHEMA_VERSION} where not exists (select 1 from schema_info);
+    update schema_info set version = ${SCHEMA_VERSION};
+    create table if not exists sessions (
+      agent text not null,
+      session_id text not null,
+      source text,
+      cwd text,
+      title text not null default '',
+      started_at text,
+      ended_at text,
+      message_count integer not null default 0,
+      source_mtime real not null default 0,
+      source_size integer not null default 0,
+      transcript text not null default '',
+      indexed_at text not null,
+      primary key(agent, session_id)
+    );
+    create index if not exists sessions_started_idx on sessions(started_at desc);
+    create index if not exists sessions_source_idx on sessions(source);
+    create virtual table if not exists session_fts using fts5(
+      agent unindexed,
+      session_id unindexed,
+      title,
+      cwd,
+      transcript,
+      tokenize='unicode61'
+    );
+    create table if not exists handoffs (
+      id text primary key,
+      target_agent text not null,
+      target_session_id text,
+      title text not null,
+      body text not null,
+      source text,
+      created_at text not null,
+      consumed_at text
+    );
+  `);
+
+  const existing = db.prepare("select source_mtime, source_size from sessions where agent = ? and session_id = ?");
+  const upsert = db.prepare(`
+    insert into sessions(agent, session_id, source, cwd, title, started_at, ended_at, message_count, source_mtime, source_size, transcript, indexed_at)
+    values(@agent, @sessionId, @source, @cwd, @title, @startedAt, @endedAt, @messageCount, @mtime, @size, @transcript, @indexedAt)
+    on conflict(agent, session_id) do update set
+      source=excluded.source, cwd=excluded.cwd, title=excluded.title,
+      started_at=excluded.started_at, ended_at=excluded.ended_at,
+      message_count=excluded.message_count, source_mtime=excluded.source_mtime,
+      source_size=excluded.source_size, transcript=excluded.transcript,
+      indexed_at=excluded.indexed_at
+  `);
+  const deleteSearch = db.prepare("delete from session_fts where agent = ? and session_id = ?");
+  const insertSearch = db.prepare("insert into session_fts(agent, session_id, title, cwd, transcript) values(?, ?, ?, ?, ?)");
+  const indexParsed = db.transaction((record) => {
+    upsert.run(record);
+    deleteSearch.run(record.agent, record.sessionId);
+    insertSearch.run(record.agent, record.sessionId, record.title, record.cwd, record.transcript);
+  });
+  const sessionCount = Number(db.prepare("select count(*) as count from sessions").get().count);
+  const searchCount = Number(db.prepare("select count(*) as count from session_fts").get().count);
+  if (sessionCount !== searchCount) {
+    db.exec(`delete from session_fts;
+      insert into session_fts(agent, session_id, title, cwd, transcript)
+      select agent, session_id, title, cwd, transcript from sessions;`);
+  }
+
+  return {
+    db,
+    needsIndex(agent, sessionId, mtime, size) {
+      const row = existing.get(agent, sessionId);
+      return !row || Number(row.source_mtime) !== Number(mtime) || Number(row.source_size) !== Number(size);
+    },
+    indexRaw({ agent, sessionId, source = null, raw, mtime = Date.now(), size = raw.length, cwd }) {
+      const parsed = parseSession(agent, raw);
+      indexParsed({
+        agent, sessionId, source, cwd: cwd || parsed.meta.cwd || null,
+        title: parsed.meta.title, startedAt: parsed.meta.startedAt,
+        endedAt: parsed.meta.endedAt, messageCount: parsed.meta.messageCount,
+        mtime, size, transcript: parsed.transcript, indexedAt: new Date().toISOString(),
+      });
+      return parsed.meta;
+    },
+    counts() {
+      const rows = db.prepare("select agent, count(*) as count from sessions group by agent").all();
+      return Object.fromEntries(rows.map((row) => [row.agent, Number(row.count)]));
+    },
+    search({ query = "", agent, days, limit = 12 }) {
+      const clauses = [];
+      const params = {};
+      if (agent) { clauses.push("sessions.agent = @agent"); params.agent = agent; }
+      if (Number.isFinite(days) && days > 0) {
+        clauses.push("coalesce(sessions.started_at, sessions.indexed_at) >= @since");
+        params.since = new Date(Date.now() - days * 86_400_000).toISOString();
+      }
+      const phrase = String(query).trim().toLowerCase();
+      const boundedLimit = Math.max(1, Math.min(50, Number(limit) || 12));
+      if (!phrase) {
+        return db.prepare(`select sessions.agent, session_id, title, cwd, started_at, ended_at, message_count, null as excerpt
+          from sessions ${clauses.length ? `where ${clauses.join(" and ")}` : ""}
+          order by coalesce(started_at, indexed_at) desc limit @limit`).all({ ...params, limit: boundedLimit })
+          .map((row) => ({ ...row, message_count: Number(row.message_count) }));
+      }
+      const terms = [...new Set(phrase.match(/[\p{L}\p{N}_-]+/gu) || [])].filter((term) => term.length > 1).slice(0, 8);
+      if (!terms.length) return [];
+      params.match = terms.map((term) => `"${term.replaceAll('"', '""')}"`).join(" OR ");
+      params.phrase = phrase;
+      params.limit = boundedLimit;
+      const where = ["session_fts match @match", ...clauses].join(" and ");
+      return db.prepare(`select sessions.agent, sessions.session_id, sessions.title, sessions.cwd,
+          sessions.started_at, sessions.ended_at, sessions.message_count,
+          snippet(session_fts, 4, '', '', ' … ', 48) as excerpt
+        from session_fts join sessions
+          on sessions.agent = session_fts.agent and sessions.session_id = session_fts.session_id
+        where ${where}
+        order by case when instr(lower(sessions.title || ' ' || session_fts.transcript), @phrase) > 0 then 0 else 1 end,
+          bm25(session_fts), coalesce(sessions.started_at, sessions.indexed_at) desc
+        limit @limit`).all(params).map((row) => ({ ...row, message_count: Number(row.message_count) }));
+    },
+    read({ agent, sessionId }) {
+      const row = db.prepare(`select agent, session_id, title, cwd, started_at, ended_at, message_count, transcript, source
+        from sessions where agent = ? and session_id = ?`).get(agent, sessionId);
+      return row ? { ...row, message_count: Number(row.message_count) } : null;
+    },
+    findSource(agent, sessionHint) {
+      const row = db.prepare(`select source, cwd from sessions
+        where agent = ? and (session_id = ? or instr(session_id, ?) > 0)
+        order by case when session_id = ? then 0 else 1 end, indexed_at desc limit 1`)
+        .get(agent, sessionHint, sessionHint, sessionHint);
+      return row || null;
+    },
+    addHandoff({ id, targetAgent, targetSessionId, title, body, source }) {
+      db.prepare(`insert or replace into handoffs(id, target_agent, target_session_id, title, body, source, created_at, consumed_at)
+        values(?, ?, ?, ?, ?, ?, ?, null)`).run(id, targetAgent, targetSessionId || null, title, body, source || null, new Date().toISOString());
+    },
+    listHandoffs(targetAgent) {
+      return targetAgent
+        ? db.prepare(`select id, target_agent, target_session_id, title, source, created_at
+            from handoffs where target_agent = ? and consumed_at is null order by created_at desc limit 20`).all(targetAgent)
+        : db.prepare(`select id, target_agent, target_session_id, title, source, created_at
+            from handoffs where consumed_at is null order by created_at desc limit 20`).all();
+    },
+    getHandoff(id, consume = false) {
+      const row = db.prepare("select * from handoffs where id = ?").get(id);
+      if (row && consume) db.prepare("update handoffs set consumed_at = ? where id = ?").run(new Date().toISOString(), id);
+      return row || null;
+    },
+    close() { db.close(); },
+  };
+}

package/package.json

@@ -1,16 +1,21 @@
 {
   "name": "tryharness",
-  "version": "0.3.0",
-  "description": "Connect Claude Code, Codex, opencode, and pi to Harness memory, session history, status, and delegated tasks.",
+  "version": "0.4.0",
+  "description": "One-command local daemon for Harness memory, coding-agent history, handoffs, and delegated tasks.",
   "bin": {
     "tryharness": "cli.mjs"
   },
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  },
   "type": "module",
   "engines": {
     "node": ">=18"
   },
   "files": [
     "cli.mjs",
+    "lib",
+    "assets",
     "README.md"
   ],
   "keywords": [
@@ -24,6 +29,7 @@
   "homepage": "https://tryharness.ai",
   "license": "MIT",
   "dependencies": {
-    "ws": "^8.18.0"
+    "better-sqlite3": "11.10.0",
+    "ws": "^8.18.3"
   }
 }