@getmarrow/install 0.1.0 → 0.1.3

package/README.md

@@ -7,8 +7,17 @@ Use it when you want Marrow to detect the local agent/runtime environment and wi
 ```bash
 npx @getmarrow/install --dry-run
 npx @getmarrow/install --yes
+npx @getmarrow/install --repair
+npx @getmarrow/install doctor
 ```
 
+## What's New in v0.1.3
+
+- Generated SDK passive runtime enables one-call agent runtime checks by default with `MARROW_AGENT_RUNTIME=true`.
+- Self-test now verifies the runtime endpoint in addition to creating a harmless decision and committing its outcome.
+- `--repair` keeps dry-run behavior safe when `--dry-run` is present and reports whether one-call runtime was verified.
+- Doctor/repair output still gives exact safe setup and repair commands without printing credential values.
+
 ## What It Detects
 
 - OpenClaw-style workspaces
@@ -53,6 +62,18 @@ Skip self-test:
 npx @getmarrow/install --yes --no-self-test
 ```
 
+Doctor check:
+
+```bash
+MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install doctor
+```
+
+Repair missing hooks/config:
+
+```bash
+MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install --repair
+```
+
 ## Trust Model
 
 This package is intended to be open source and auditable. It prints every file it will touch, requires `--yes` to write, does not store API keys in project files, and supports MCP-only, SDK-only, both, and markdown-only setups.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getmarrow/install",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Universal installer for Marrow passive agent setup.",
   "bin": {
     "marrow-install": "bin/marrow-install.js"

package/src/installer.js

@@ -11,6 +11,8 @@ function parseArgs(argv) {
     cwd: process.cwd(),
     yes: false,
     dryRun: false,
+    doctor: false,
+    repair: false,
     mode: 'auto',
     apiKey: process.env.MARROW_API_KEY || '',
     baseUrl: process.env.MARROW_BASE_URL || DEFAULT_BASE_URL,
@@ -22,7 +24,12 @@ function parseArgs(argv) {
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
     if (arg === '--yes' || arg === '-y') options.yes = true;
+    else if (arg === '--repair' || arg === 'repair') {
+      options.repair = true;
+      options.yes = true;
+    }
     else if (arg === '--dry-run') options.dryRun = true;
+    else if (arg === '--doctor' || arg === 'doctor' || arg === 'check') options.doctor = true;
     else if (arg === '--json') options.json = true;
     else if (arg === '--no-self-test') options.selfTest = false;
     else if (arg === '--self-test') options.selfTest = true;
@@ -56,11 +63,15 @@ function usage() {
   return `Usage:
   npx @getmarrow/install --dry-run
   npx @getmarrow/install --yes
+  npx @getmarrow/install --repair
+  npx @getmarrow/install doctor
   npx @getmarrow/install --mcp --yes
   npx @getmarrow/install --sdk --yes
 
 Options:
   --dry-run          Print planned changes without writing
+  --doctor           Check install health without writing
+  --repair           Write missing hooks/config, then run self-test and status check
   --yes, -y          Write detected config files
   --mode <mode>      auto, mcp, sdk, both, or md
   --key <key>        Marrow API key for self-test. Prefer MARROW_API_KEY because CLI args can appear in process listings.
@@ -131,6 +142,24 @@ function detectEnvironment(cwd = process.cwd(), env = process.env) {
   };
 }
 
+function findLikelyEnvFiles(detection, env = process.env) {
+  const home = env.HOME || env.USERPROFILE || os.homedir();
+  const candidates = [
+    path.join(detection.root, '.env'),
+    path.join(detection.root, '.env.local'),
+    path.join(detection.root, '.marrow', 'env'),
+    path.join(detection.root, '.marrow', 'env.local'),
+    path.join(home, '.marrow', 'env'),
+    path.join(home, '.openclaw', 'credentials', 'marrow-mcp.env'),
+    path.join(home, '.openclaw', 'gateway.systemd.env'),
+  ];
+  return candidates.filter((filePath) => {
+    if (!exists(filePath)) return false;
+    const raw = safeRead(filePath);
+    return /\bMARROW_API_KEY\s*=/.test(raw) || /\bMARROW_KEY(_[A-Z0-9]+)?\s*=/.test(raw);
+  });
+}
+
 function passiveInstructions() {
   return `${MARROW_BLOCK_START}
 ## Marrow Passive Agent Memory
@@ -163,8 +192,10 @@ if (apiKey && !globalThis.__MARROW_PASSIVE_RUNTIME__) {
   });
 
   const runtime = marrow.createPassiveRuntime({
-    includeValueReport: process.env.MARROW_PASSIVE_VALUE_REPORT === 'true',
+    includeValueReport: process.env.MARROW_PASSIVE_VALUE_REPORT !== 'false',
     valueReportPeriod: process.env.MARROW_VALUE_REPORT_PERIOD || '7d',
+    useAgentRuntime: process.env.MARROW_AGENT_RUNTIME !== 'false',
+    useWorkflowGate: process.env.MARROW_WORKFLOW_GATE !== 'false',
   });
 
   runtime.install();
@@ -179,6 +210,9 @@ MARROW_BASE_URL=${DEFAULT_BASE_URL}
 MARROW_FLEET_AGENT_ID=agent-or-fleet-id
 MARROW_ENFORCEMENT_MODE=auto
 MARROW_PASSIVE_BRIEF=auto
+MARROW_PASSIVE_VALUE_REPORT=true
+MARROW_AGENT_RUNTIME=true
+MARROW_WORKFLOW_GATE=true
 `;
 }
 
@@ -337,7 +371,7 @@ function applyPlan(plan, options) {
 
     const changed = before !== after;
     changes.push({ path: write.path, label: write.label, changed });
-    if (changed && options.yes && !options.dryRun) {
+    if (changed && options.yes && !options.dryRun && !options.doctor) {
       fs.mkdirSync(path.dirname(write.path), { recursive: true });
       fs.writeFileSync(write.path, after);
     }
@@ -363,7 +397,13 @@ async function requestJson(url, options) {
 
 async function runSelfTest(options) {
   if (!options.selfTest) return { skipped: true, reason: 'disabled' };
-  if (!options.apiKey) return { skipped: true, reason: 'missing MARROW_API_KEY' };
+  if (!options.apiKey) {
+    return {
+      skipped: true,
+      reason: 'missing MARROW_API_KEY',
+      exact_fix: 'export MARROW_API_KEY=mrw_live_... && npx @getmarrow/install --repair',
+    };
+  }
 
   const headers = {
     authorization: `Bearer ${options.apiKey}`,
@@ -396,6 +436,23 @@ async function runSelfTest(options) {
   });
 
   const status = await requestJson(`${baseUrl}/v1/agent/status`, { headers });
+  const runtime = await requestJson(`${baseUrl}/v1/agent/runtime`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({
+      action: 'Marrow passive install self-test: verify one-call agent runtime and outcome closure',
+      type: 'process',
+      role: 'general',
+      surfaces: ['workspace'],
+      proof: {
+        checks: ['installer self-test'],
+        outcome: 'self-test outcome committed',
+      },
+    }),
+  }).catch((error) => ({
+    ok: false,
+    error: error instanceof Error ? error.message : String(error),
+  }));
   return {
     skipped: false,
     decision_id: decisionId,
@@ -403,6 +460,11 @@ async function runSelfTest(options) {
     health: status.health || null,
     last_event_at: status.last_event_at || null,
     recommended_fix: status.recommended_fix || null,
+    next_action: status.next_action || null,
+    auto_outcome_closure: status.auto_outcome_closure || null,
+    runtime_active: Boolean(runtime && runtime.ok !== false),
+    runtime_exact_next_action: runtime.exact_next_action || null,
+    runtime_before_you_act: runtime.before_you_act || null,
   };
 }
 
@@ -426,10 +488,30 @@ function printReport(report) {
   process.stdout.write('\nSelf-test:\n');
   if (report.selfTest.skipped) {
     process.stdout.write(`- skipped: ${report.selfTest.reason}\n`);
+    if (report.selfTest.exact_fix) process.stdout.write(`- exact fix: ${report.selfTest.exact_fix}\n`);
   } else {
     process.stdout.write(`- active: ${report.selfTest.active ? 'yes' : 'no'}\n`);
     process.stdout.write(`- decision_id: ${report.selfTest.decision_id}\n`);
     process.stdout.write(`- health: ${report.selfTest.health || 'unknown'}\n`);
+    process.stdout.write(`- one-call runtime: ${report.selfTest.runtime_active ? 'active' : 'not verified'}\n`);
+    if (report.selfTest.next_action) process.stdout.write(`- next action: ${report.selfTest.next_action}\n`);
+  }
+
+  if (report.remediation) {
+    process.stdout.write('\nRemediation:\n');
+    process.stdout.write(`- attempted: ${report.remediation.attempted ? 'yes' : 'no'}\n`);
+    process.stdout.write(`- fixed config: ${report.remediation.fixedConfig ? 'yes' : 'no'}\n`);
+    process.stdout.write(`- self-test passed: ${report.remediation.selfTestPassed ? 'yes' : 'no'}\n`);
+    if (report.remediation.message) process.stdout.write(`- result: ${report.remediation.message}\n`);
+  }
+
+  if (report.writeMode === 'doctor') {
+    process.stdout.write('\nDoctor:\n');
+    process.stdout.write(`- Marrow active: ${report.doctor.active ? 'yes' : 'no'}\n`);
+    process.stdout.write(`- missing env: ${report.doctor.missingEnv.length ? report.doctor.missingEnv.join(', ') : 'none'}\n`);
+    if (report.doctor.envHints.length) process.stdout.write(`- possible env files: ${report.doctor.envHints.join(', ')}\n`);
+    process.stdout.write(`- missing hooks/config: ${report.doctor.missingHooks.length ? report.doctor.missingHooks.join('; ') : 'none'}\n`);
+    if (report.doctor.recommendedFix) process.stdout.write(`- recommended fix: ${report.doctor.recommendedFix}\n`);
   }
 
   if (report.writeMode === 'dry-run') {
@@ -447,13 +529,30 @@ function printReport(report) {
 async function install(options) {
   const detection = detectEnvironment(options.cwd);
   const plan = buildPlan(detection, options);
-  const writeMode = options.yes && !options.dryRun ? 'write' : 'dry-run';
+  const writeMode = options.doctor ? 'doctor' : options.dryRun ? 'dry-run' : options.repair ? 'repair' : options.yes ? 'write' : 'dry-run';
   const changes = applyPlan(plan, options);
+  const envHints = options.apiKey ? [] : findLikelyEnvFiles(detection);
   const selfTest = await runSelfTest(options).catch((error) => ({
     skipped: false,
     active: false,
     error: error instanceof Error ? error.message : String(error),
   }));
+  const changedConfig = changes.some((change) => change.changed);
+  const selfTestPassed = Boolean(!selfTest.skipped && selfTest.active && !selfTest.error);
+  const remediation = options.repair
+    ? {
+      attempted: true,
+      fixedConfig: changedConfig,
+      selfTestPassed,
+      message: selfTestPassed
+        ? selfTest.health === 'healthy'
+          ? 'I fixed Marrow passive config, one-call runtime is active, and self-test passed.'
+          : `I fixed Marrow passive config and self-test passed; status is ${selfTest.health || 'unknown'}${selfTest.next_action ? `. Next action: ${selfTest.next_action}` : ''}.`
+        : selfTest.skipped
+        ? `Config repair ran, but self-test skipped: ${selfTest.reason}.`
+        : `Config repair ran, but self-test failed: ${selfTest.error || 'unknown error'}.`,
+    }
+    : null;
 
   return {
     root: detection.root,
@@ -469,6 +568,18 @@ async function install(options) {
       mcpConfig: detection.mcpConfig,
     },
     changes,
+    doctor: {
+      active: Boolean(!selfTest.skipped && selfTest.active),
+      missingEnv: options.apiKey ? [] : ['MARROW_API_KEY'],
+      envHints,
+      missingHooks: changes.filter((change) => change.changed).map((change) => change.label),
+      recommendedFix: selfTest.recommended_fix || (!options.apiKey
+        ? envHints.length
+          ? `MARROW_API_KEY was found in a likely env file at ${envHints[0]}. Load that key from trusted secret storage, export only MARROW_API_KEY, then run npx @getmarrow/install --repair.`
+          : 'Set MARROW_API_KEY, then run npx @getmarrow/install --repair.'
+        : null),
+    },
+    remediation,
     selfTest,
     warnings: options.keyFromArg
       ? ['Avoid --key in shared shells because command-line arguments can be visible in process listings. Prefer MARROW_API_KEY in your environment or secret manager.']

package/bin/marrow-install.js

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-
-const { runCli } = require('../src/installer');
-
-runCli(process.argv.slice(2)).catch((error) => {
-  const message = error instanceof Error ? error.message : String(error);
-  process.stderr.write(`marrow-install failed: ${message}\n`);
-  process.exit(1);
-});