@openscout/scout 0.2.70 → 0.2.73

package/dist/statusline.mjs

@@ -0,0 +1,287 @@
+#!/usr/bin/env bun
+// ../../apps/desktop/src/cli/commands/statusline.ts
+import { spawn } from "child_process";
+
+// ../runtime/src/claude-statusline.ts
+import { appendFile, mkdir, readFile, writeFile } from "fs/promises";
+import { basename, dirname, join as join2 } from "path";
+
+// ../runtime/src/support-paths.ts
+import { homedir } from "os";
+import { join } from "path";
+var OPENSCOUT_RPC_CUTOVER_MARKER = "rpc-runtime-cutover-v1";
+function resolveOpenScoutSupportPaths() {
+  const home = homedir();
+  const supportDirectory = process.env.OPENSCOUT_SUPPORT_DIRECTORY ?? join(home, "Library", "Application Support", "OpenScout");
+  const logsDirectory = join(supportDirectory, "logs");
+  const runtimeDirectory = join(supportDirectory, "runtime");
+  const catalogDirectory = join(supportDirectory, "catalog");
+  const controlHome = process.env.OPENSCOUT_CONTROL_HOME ?? join(home, ".openscout", "control-plane");
+  const knowledgeDirectory = join(controlHome, "knowledge");
+  return {
+    supportDirectory,
+    logsDirectory,
+    appLogsDirectory: join(logsDirectory, "app"),
+    brokerLogsDirectory: join(logsDirectory, "broker"),
+    runtimeDirectory,
+    catalogDirectory,
+    relayAgentsDirectory: join(runtimeDirectory, "agents"),
+    settingsPath: join(supportDirectory, "settings.json"),
+    harnessCatalogPath: join(catalogDirectory, "harness-catalog.json"),
+    relayAgentsRegistryPath: join(supportDirectory, "relay-agents.json"),
+    managedInstallsPath: join(supportDirectory, "managed-installs.json"),
+    hostInfoPath: join(supportDirectory, ".host-info"),
+    relayHubDirectory: process.env.OPENSCOUT_RELAY_HUB ?? join(home, ".openscout", "relay"),
+    controlHome,
+    knowledgeDirectory,
+    knowledgeQmdDirectory: join(knowledgeDirectory, "qmd"),
+    knowledgeSqlitePath: join(knowledgeDirectory, "knowledge.sqlite"),
+    desktopStatusPath: join(supportDirectory, "agent-status.json"),
+    workspaceStatePath: join(supportDirectory, "workspace-state.json"),
+    cutoverMarkerPath: join(supportDirectory, OPENSCOUT_RPC_CUTOVER_MARKER)
+  };
+}
+
+// ../runtime/src/claude-statusline.ts
+function resolveClaudeStatuslineDirectory() {
+  return join2(resolveOpenScoutSupportPaths().runtimeDirectory, "statusline");
+}
+function resolveClaudeStatuslineDelegatePath() {
+  return join2(resolveClaudeStatuslineDirectory(), "claude-delegate.json");
+}
+function resolveClaudeStatuslineWrapperPath() {
+  return join2(resolveClaudeStatuslineDirectory(), "claude-statusline.sh");
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function numberValue(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return;
+  return value;
+}
+function percentLabel(value) {
+  const number = numberValue(value);
+  if (number === undefined)
+    return null;
+  if (Math.abs(number - Math.round(number)) < 0.05) {
+    return `${Math.round(number)}%`;
+  }
+  return `${number.toFixed(1)}%`;
+}
+function recordValue(value) {
+  return isRecord(value) ? value : null;
+}
+function parseClaudeStatuslinePayload(input) {
+  try {
+    const parsed = JSON.parse(input);
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function normalizeClaudeStatuslineSnapshot(input, capturedAt = Date.now()) {
+  const workspace = recordValue(input.workspace);
+  const cwd = stringValue(input.cwd) ?? stringValue(workspace?.current_dir);
+  const snapshot = {
+    ...input,
+    openscoutCapturedAt: numberValue(input.openscoutCapturedAt) ?? capturedAt
+  };
+  if (cwd && !stringValue(snapshot.cwd)) {
+    snapshot.cwd = cwd;
+  }
+  return snapshot;
+}
+async function captureClaudeStatuslineSnapshot(input, options = {}) {
+  const parsed = typeof input === "string" ? parseClaudeStatuslinePayload(input) : input;
+  if (!parsed) {
+    return { captured: false, reason: typeof input === "string" ? "invalid-json" : "invalid-record" };
+  }
+  if (!isRecord(parsed)) {
+    return { captured: false, reason: "invalid-record" };
+  }
+  const directory = options.directory ?? resolveClaudeStatuslineDirectory();
+  const latestPath = join2(directory, "claude-latest.json");
+  const historyPath = join2(directory, "claude-history.jsonl");
+  const snapshot = normalizeClaudeStatuslineSnapshot(parsed, options.capturedAt);
+  const line = JSON.stringify(snapshot);
+  await mkdir(directory, { recursive: true });
+  await Promise.all([
+    writeFile(latestPath, `${line}
+`, "utf8"),
+    appendFile(historyPath, `${line}
+`, "utf8")
+  ]);
+  return {
+    captured: true,
+    latestPath,
+    historyPath,
+    snapshot
+  };
+}
+async function readClaudeStatuslineDelegate(path = resolveClaudeStatuslineDelegatePath()) {
+  try {
+    const parsed = JSON.parse(await readFile(path, "utf8"));
+    if (!isRecord(parsed))
+      return null;
+    const command = stringValue(parsed.command);
+    if (!command)
+      return null;
+    return {
+      version: 1,
+      command,
+      source: parsed.source === "manual" ? "manual" : "claude-settings.statusLine",
+      installedAt: numberValue(parsed.installedAt) ?? Date.now(),
+      ...isRecord(parsed.statusLine) ? { statusLine: parsed.statusLine } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function isOpenScoutClaudeStatuslineCommand(command, wrapperPath = resolveClaudeStatuslineWrapperPath()) {
+  const trimmed = command.trim();
+  if (!trimmed)
+    return false;
+  if (trimmed.includes(wrapperPath))
+    return true;
+  return /(?:^|\s|["'])\S*scout(?:["']|\s)+statusline\s+claude(?:\s|$)/u.test(trimmed);
+}
+function formatClaudeStatuslineFallback(snapshot) {
+  if (!snapshot) {
+    return "Scout | Claude status";
+  }
+  const model = recordValue(snapshot.model);
+  const workspace = recordValue(snapshot.workspace);
+  const context = recordValue(snapshot.context_window);
+  const rateLimits = recordValue(snapshot.rate_limits);
+  const fiveHour = recordValue(rateLimits?.five_hour);
+  const sevenDay = recordValue(rateLimits?.seven_day);
+  const cwd = stringValue(snapshot.cwd) ?? stringValue(workspace?.current_dir);
+  const parts = [
+    "Scout",
+    stringValue(model?.display_name) ?? stringValue(model?.id) ?? "Claude"
+  ];
+  if (cwd) {
+    parts.push(basename(cwd));
+  }
+  const contextPercent = percentLabel(context?.used_percentage);
+  if (contextPercent) {
+    parts.push(`ctx ${contextPercent}`);
+  }
+  const fiveHourPercent = percentLabel(fiveHour?.used_percentage);
+  if (fiveHourPercent) {
+    parts.push(`5h ${fiveHourPercent}`);
+  }
+  const sevenDayPercent = percentLabel(sevenDay?.used_percentage);
+  if (sevenDayPercent) {
+    parts.push(`7d ${sevenDayPercent}`);
+  }
+  return parts.join(" | ");
+}
+
+// ../../apps/desktop/src/cli/commands/statusline.ts
+var DELEGATE_TIMEOUT_MS = 150;
+var MAX_DELEGATE_OUTPUT_BYTES = 64 * 1024;
+async function runStatuslineCommand(context, args) {
+  const [provider, ...rest] = args;
+  if (provider !== "claude") {
+    context.output.writeText("usage: scout statusline claude");
+    return;
+  }
+  if (process.stdin.isTTY) {
+    context.output.writeText("usage: scout statusline claude < statusline.json");
+    return;
+  }
+  const delegateRequested = rest.includes("--delegate") || context.env.OPENSCOUT_STATUSLINE_RUN_DELEGATE === "1";
+  const noDelegate = rest.includes("--no-delegate") || context.env.OPENSCOUT_STATUSLINE_DELEGATE === "1";
+  const raw = await readStdin();
+  const snapshot = parseClaudeStatuslinePayload(raw);
+  try {
+    await captureClaudeStatuslineSnapshot(snapshot ?? raw);
+  } catch {}
+  if (delegateRequested && !noDelegate) {
+    const delegate = await readClaudeStatuslineDelegate();
+    if (delegate?.command && !isOpenScoutClaudeStatuslineCommand(delegate.command)) {
+      const delegated = await runDelegateStatusline(delegate.command, raw, context.env);
+      if (delegated) {
+        writeStatusline(delegated);
+        return;
+      }
+    }
+  }
+  writeStatusline(formatClaudeStatuslineFallback(snapshot));
+}
+async function readStdin() {
+  let out = "";
+  process.stdin.setEncoding("utf8");
+  for await (const chunk of process.stdin) {
+    out += typeof chunk === "string" ? chunk : String(chunk);
+  }
+  return out;
+}
+function writeStatusline(value) {
+  const normalized = value.trimEnd();
+  process.stdout.write(`${normalized}
+`);
+}
+function runDelegateStatusline(command, input, env) {
+  return new Promise((resolve) => {
+    const child = spawn("sh", ["-lc", command], {
+      env: {
+        ...env,
+        OPENSCOUT_STATUSLINE_DELEGATE: "1"
+      },
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    let settled = false;
+    let stdout = "";
+    const done = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value?.trimEnd() || null);
+    };
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      done(null);
+    }, DELEGATE_TIMEOUT_MS);
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      if (stdout.length >= MAX_DELEGATE_OUTPUT_BYTES)
+        return;
+      stdout += String(chunk).slice(0, MAX_DELEGATE_OUTPUT_BYTES - stdout.length);
+    });
+    child.once("error", () => done(null));
+    child.once("close", (code) => done(code === 0 ? stdout : null));
+    child.stdin.on("error", () => {
+      return;
+    });
+    child.stdin.end(input);
+  });
+}
+
+// src/statusline.ts
+try {
+  const args = process.argv[2] === "statusline" ? process.argv.slice(3) : process.argv.slice(2);
+  const context = {
+    env: process.env,
+    output: {
+      writeText(value) {
+        process.stdout.write(`${value}
+`);
+      }
+    },
+    stderr(message) {
+      process.stderr.write(`${message}
+`);
+    }
+  };
+  await runStatuslineCommand(context, args);
+} catch {
+  process.stdout.write(`Scout | Claude status
+`);
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@openscout/scout",
-  "version": "0.2.70",
+  "version": "0.2.73",
   "description": "Public Scout package that installs the `scout` command and bundled local runtime",
-  "license": "UNLICENSED",
+  "license": "Apache-2.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -14,7 +14,11 @@
   },
   "homepage": "https://github.com/arach/openscout#readme",
   "bin": {
-    "scout": "./bin/scout.mjs"
+    "scout": "./bin/scout",
+    "openscout-runtime": "./bin/openscout-runtime.mjs"
+  },
+  "engines": {
+    "bun": ">=1.2"
   },
   "files": [
     "bin",
@@ -22,7 +26,7 @@
     "README.md"
   ],
   "dependencies": {
-    "node-pty": "1.2.0-beta.12",
+    "@lydell/node-pty": "1.2.0-beta.12",
     "picomatch": "^4.0.4",
     "ws": "^8.18.3"
   },