phewsh 0.12.1 → 0.12.3

package/README.md

@@ -15,6 +15,34 @@ phewsh              # enter the interactive shell
 phewsh serve        # start live execution bridge for phewsh.com/intent
 ```
 
+## No API key needed
+
+phewsh is not another agent — it's the layer that uses the ones you already
+have. If Claude Code, Codex CLI, Gemini CLI, Cursor Agent, or OpenCode is
+installed, phewsh runs through it on **its own login** (your Claude
+subscription, ChatGPT plan, Google account):
+
+```bash
+phewsh ai run "what should I build next?"     # auto-uses an installed agent CLI
+phewsh ai run -p codex "..."                  # pin one explicitly
+phewsh ai providers                           # see what's installed
+```
+
+API keys (OpenRouter, Anthropic, Groq, …) and PHEWSH pooled credits remain
+available as alternatives — `phewsh login --set-key`.
+
+## Two packages, one system
+
+- **`phewsh`** (this package) — the CLI: intent authoring, sync, bridges,
+  receipts, dispatch.
+- **`phewsh-mcp-server`** — the MCP server that `phewsh mcp setup` wires into
+  Claude Code / Cursor / any MCP client. It gives an *interactive* agent
+  session your project's briefing, task queue, and enforcement gate over
+  stdio, and shares state with the bridges (`~/.phewsh/`).
+
+Rule of thumb: `phewsh serve` = dispatch tasks *to* your agents.
+`phewsh mcp setup` = your agents pull tasks *from* PHEWSH mid-session.
+
 ## Live Execution
 
 Connect the web app to your local machine for real-time task execution:
@@ -67,6 +95,7 @@ phewsh pull               # Sync cloud to local
 phewsh mcp setup          # Configure MCP server for agent connectivity
 phewsh mcp serve          # Coordination bridge — route work to live agents
 phewsh receipts           # Proof trail — what agents actually did, with evidence
+phewsh update             # Update phewsh to the latest version
 phewsh style              # Build your style identity
 ```
 

package/bin/phewsh.js

@@ -64,6 +64,7 @@ const COMMANDS = {
   watch:   () => require('../commands/watch')(),
   mcp:     () => require('../commands/mcp')(),
   receipts: () => require('../commands/receipts')(),
+  update:  () => require('../commands/update')(),
   serve:   () => require('../commands/serve')(),
   sequence: () => require('../commands/sequence')(),
   seq:     () => require('../commands/sequence')(),
@@ -103,6 +104,7 @@ function showHelp() {
   console.log(`  ${b(w('configure'))}`);
   console.log(`    ${cyan('login')}      ${g('Identity + API key + cloud sync')}`);
   console.log(`    ${cyan('link')}       ${g('Link local .intent/ to cloud project')}`);
+  console.log(`    ${cyan('update')}     ${g('Update phewsh to the latest version')}`);
   console.log('');
   console.log(`  ${g('Works in: Claude Code · Cursor · ChatGPT · any MCP agent')}`);
   console.log(`  ${g('No account needed. Account adds sync + sharing.')}`);
@@ -127,7 +129,7 @@ function checkForUpdates() {
           newer[2] > current[2];
         if (isNewer) {
           console.log(g(`\n  Update available: ${pkg.version} → ${data.version}`));
-          console.log(g(`  Run: npm install -g phewsh\n`));
+          console.log(g(`  Run: phewsh update\n`));
         }
       }
     })

package/commands/ai.js

@@ -6,6 +6,7 @@ const {
   getProvider, listProviders, detectProvider,
   buildHeaders, buildBody, getUrl, streamParser,
 } = require('../lib/providers');
+const { HARNESSES, detectInstalled, listHarnesses, runViaHarness } = require('../lib/harnesses');
 
 const CONFIG_PATH = path.join(os.homedir(), '.phewsh', 'config.json');
 const INTENT_DIR = path.join(process.cwd(), '.intent');
@@ -170,16 +171,25 @@ async function main() {
 
   Examples:
     phewsh ai run "what should I build next?"
+    phewsh ai run -p claude-code "use my Claude subscription — no API key"
+    phewsh ai run -p codex "use my ChatGPT plan — no API key"
     phewsh ai run -p openrouter "compare these approaches"
-    phewsh ai run -p groq -m llama-3.3-70b-versatile "quick question"
     phewsh ai run -p ollama "local inference, no API key needed"
+
+  No API key? phewsh automatically runs through an installed agent CLI
+  (Claude Code, Codex, Gemini, Cursor, OpenCode) using its own login.
     `);
     return;
   }
 
   if (subcommand === 'providers') {
     const config = loadConfig() || {};
-    console.log('\n  Available providers:\n');
+    console.log('\n  Subscription harnesses (no API key — they carry their own login):\n');
+    for (const h of listHarnesses()) {
+      const status = h.installed ? '\x1b[32minstalled\x1b[0m' : '\x1b[2mnot installed\x1b[0m';
+      console.log(`  ${h.id.padEnd(12)} ${h.label.padEnd(26)} ${status}  (${h.auth})`);
+    }
+    console.log('\n  API providers:\n');
     for (const p of listProviders()) {
       const isDefault = (config.defaultProvider || 'anthropic') === p.id;
       const hasKey = !!(config.providerKeys?.[p.id] || (p.keyEnvVar && process.env[p.keyEnvVar]));
@@ -222,30 +232,48 @@ async function main() {
       process.exit(1);
     }
 
-    const config = loadConfig();
-    if (!config) {
-      console.error('\n  Not logged in. Run `phewsh login` first.\n');
-      process.exit(1);
+    const config = loadConfig() || {};
+    const intentFiles = loadIntentContext();
+    const systemPrompt = buildSystemPrompt(intentFiles);
+    const contextLine = intentFiles.length > 0
+      ? `\n  Context: ${intentFiles.map(f => f.file).join(', ')}`
+      : '\n  No .intent/ found — running without project context';
+
+    // Harnesses double as providers: they carry their own auth (your Claude /
+    // ChatGPT / Google subscription), so no API key is needed in phewsh.
+    const requested = flags.provider || config.defaultProvider;
+    if (requested && HARNESSES[requested]) {
+      console.log(contextLine);
+      console.log(`  Provider: ${HARNESSES[requested].label} (your ${HARNESSES[requested].auth} — no API key)`);
+      await runViaHarness(requested, systemPrompt, prompt);
+      return;
     }
 
     const provider = resolveProvider(config, flags.provider);
     const model = flags.model || config.providerModels?.[provider.id] || provider.defaultModel;
-
     const apiKey = resolveApiKey(config, provider);
+
+    // No key? Fall back to an installed harness instead of erroring — that's
+    // what platform-agnostic means in practice.
+    if (!apiKey && !provider.noKey && !flags.provider) {
+      const harness = detectInstalled();
+      if (harness) {
+        console.log(contextLine);
+        console.log(`  Provider: ${HARNESSES[harness].label} (your ${HARNESSES[harness].auth} — no API key)`);
+        console.log(`  \x1b[2mTip: pin it with \`phewsh ai run -p ${harness}\` or add an API key via \`phewsh login --set-key\`\x1b[0m`);
+        await runViaHarness(harness, systemPrompt, prompt);
+        return;
+      }
+    }
+
     if (!apiKey && !provider.noKey) {
       console.error(`\n  No API key for ${provider.name}.`);
-      console.error(`  Run \`phewsh login --set-key\` or set ${provider.keyEnvVar}.\n`);
+      console.error(`  Run \`phewsh login --set-key\`, set ${provider.keyEnvVar},`);
+      console.error(`  or use an installed agent CLI: phewsh ai run -p claude-code|codex|gemini|cursor|opencode\n`);
       process.exit(1);
     }
 
-    const intentFiles = loadIntentContext();
-    const systemPrompt = buildSystemPrompt(intentFiles);
-
-    if (intentFiles.length > 0) {
-      console.log(`\n  Context: ${intentFiles.map(f => f.file).join(', ')}`);
-    } else {
-      console.log('\n  No .intent/ found — running without project context');
-    }
+    console.log(contextLine);
     console.log(`  Provider: ${provider.name} | Model: ${model}`);
 
     await streamResponse(config, provider, model, systemPrompt, prompt);

package/commands/serve.js

@@ -35,27 +35,16 @@ function getPort() {
 
 // ─── Runtime Detection ─────────────────────────────────────────────────────
 
-// Harness runners — how to invoke each agent CLI headlessly. PHEWSH is not a
+// Harness runners — shared table in lib/harnesses.js. PHEWSH is not a
 // harness; it's the layer that dispatches to whichever harnesses you have.
 // Detection is honest: a runtime is only "connected" if its binary is on PATH.
-const RUNNERS = {
-  'claude-code': { bin: 'claude',       label: 'Claude Code',  args: (p) => ['-p', p, '--output-format', 'text'] },
-  'codex':       { bin: 'codex',        label: 'Codex CLI',    args: (p) => ['exec', p] },
-  'gemini':      { bin: 'gemini',       label: 'Gemini CLI',   args: (p) => ['-p', p] },
-  'cursor':      { bin: 'cursor-agent', label: 'Cursor Agent', args: (p) => ['-p', p, '--output-format', 'text'] },
-  'opencode':    { bin: 'opencode',     label: 'OpenCode',     args: (p) => ['run', p] },
-};
+const { HARNESSES: RUNNERS, isInstalled } = require('../lib/harnesses');
 
 function detectRuntimes() {
   const runtimes = [];
 
   for (const [id, r] of Object.entries(RUNNERS)) {
-    let connected = false;
-    try {
-      execSync(`which ${r.bin}`, { stdio: 'pipe' });
-      connected = true;
-    } catch { /* not installed */ }
-    runtimes.push({ id, label: r.label, connected });
+    runtimes.push({ id, label: r.label, connected: isInstalled(id) });
   }
 
   // Always report human as available

package/commands/update.js

@@ -0,0 +1,79 @@
+// phewsh update — update the CLI to the latest published version.
+//
+// Usage:
+//   phewsh update           Check npm and install the latest version
+//   phewsh update --check   Just compare versions, don't install
+
+const { spawn } = require('child_process');
+
+const b = (s) => `\x1b[1m${s}\x1b[0m`;
+const w = (s) => `\x1b[97m${s}\x1b[0m`;
+const g = (s) => `\x1b[38;2;130;142;138m${s}\x1b[0m`;
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+
+function isNewer(latest, current) {
+  const l = latest.split('.').map(Number);
+  const c = current.split('.').map(Number);
+  return l[0] !== c[0] ? l[0] > c[0] : l[1] !== c[1] ? l[1] > c[1] : l[2] > c[2];
+}
+
+async function main() {
+  const checkOnly = process.argv.includes('--check');
+  const pkg = require('../package.json');
+
+  console.log('');
+  console.log(`  ${b(w('phewsh update'))}`);
+  console.log('');
+  console.log(`  ${g('current:')} v${pkg.version}`);
+
+  let latest;
+  try {
+    const res = await fetch(`https://registry.npmjs.org/${pkg.name}/latest`, {
+      signal: AbortSignal.timeout(5000),
+    });
+    latest = (await res.json()).version;
+  } catch {
+    console.log(`  ${yellow('Could not reach the npm registry. Try again later.')}`);
+    console.log('');
+    return;
+  }
+  console.log(`  ${g('latest: ')} v${latest}`);
+  console.log('');
+
+  if (!latest || !isNewer(latest, pkg.version)) {
+    console.log(`  ${green('Already up to date.')}`);
+    console.log('');
+    return;
+  }
+
+  if (checkOnly) {
+    console.log(`  ${w(`v${latest} available.`)} Run ${w('phewsh update')} to install.`);
+    console.log('');
+    return;
+  }
+
+  console.log(`  ${g('Installing')} ${w(`phewsh@${latest}`)} ${g('via npm…')}`);
+  console.log('');
+
+  const child = spawn('npm', ['install', '-g', `${pkg.name}@latest`], { stdio: 'inherit' });
+  child.on('close', (code) => {
+    console.log('');
+    if (code === 0) {
+      console.log(`  ${green('✓')} Updated to v${latest}. New shells pick it up immediately.`);
+    } else {
+      console.log(`  ${yellow('Update failed')} (npm exited ${code}).`);
+      console.log(`  ${g('If it was a permissions error, fix your npm prefix or run:')}`);
+      console.log(`  ${w(`sudo npm install -g ${pkg.name}@latest`)}`);
+    }
+    console.log('');
+    process.exit(code ?? 0);
+  });
+  child.on('error', (err) => {
+    console.log(`  ${yellow('Could not run npm:')} ${err.message}`);
+    console.log('');
+    process.exit(1);
+  });
+}
+
+module.exports = main;

package/lib/harnesses.js

@@ -0,0 +1,67 @@
+// Agent harnesses installed on this machine, and how to invoke them headlessly.
+//
+// PHEWSH is not a harness — it's the layer that uses the ones you already
+// have. Each of these carries its OWN auth (Claude Code uses your Claude
+// subscription, Codex your ChatGPT plan, Gemini your Google login), so going
+// through them needs no API key in phewsh at all.
+//
+// Used by:
+//   phewsh serve     — web-dispatched jobs execute through these
+//   phewsh ai        — harnesses double as no-key providers
+
+const { execSync, spawn } = require('child_process');
+
+const HARNESSES = {
+  'claude-code': { bin: 'claude',       label: 'Claude Code',  auth: 'Claude subscription / Console', args: (p) => ['-p', p, '--output-format', 'text'] },
+  'codex':       { bin: 'codex',        label: 'Codex CLI',    auth: 'ChatGPT plan',                  args: (p) => ['exec', p] },
+  'gemini':      { bin: 'gemini',       label: 'Gemini CLI',   auth: 'Google login',                  args: (p) => ['-p', p] },
+  'cursor':      { bin: 'cursor-agent', label: 'Cursor Agent', auth: 'Cursor account',                args: (p) => ['-p', p, '--output-format', 'text'] },
+  'opencode':    { bin: 'opencode',     label: 'OpenCode',     auth: 'OpenCode Zen / configured',     args: (p) => ['run', p] },
+};
+
+function isInstalled(id) {
+  const h = HARNESSES[id];
+  if (!h) return false;
+  try { execSync(`which ${h.bin}`, { stdio: 'pipe' }); return true; } catch { return false; }
+}
+
+/** First installed harness in preference order, or null. */
+function detectInstalled() {
+  for (const id of Object.keys(HARNESSES)) {
+    if (isInstalled(id)) return id;
+  }
+  return null;
+}
+
+function listHarnesses() {
+  return Object.entries(HARNESSES).map(([id, h]) => ({ id, ...h, installed: isInstalled(id) }));
+}
+
+/**
+ * Run a prompt through a harness, streaming stdout to the terminal.
+ * stderr is buffered and only surfaced on failure (codex/gemini chat on it).
+ */
+function runViaHarness(id, systemPrompt, userPrompt) {
+  const h = HARNESSES[id];
+  if (!h) return Promise.reject(new Error(`Unknown harness: ${id}`));
+  const prompt = systemPrompt ? `${systemPrompt}\n\n---\n\n${userPrompt}` : userPrompt;
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(h.bin, h.args(prompt), { stdio: ['pipe', 'pipe', 'pipe'] });
+    // Some harnesses (codex exec, gemini) wait for stdin EOF before running.
+    child.stdin.end();
+
+    let stderr = '';
+    process.stdout.write('\n');
+    child.stdout.on('data', (d) => process.stdout.write(d));
+    child.stderr.on('data', (d) => { stderr += d.toString(); });
+    child.on('close', (code) => {
+      process.stdout.write('\n');
+      if (code === 0) resolve();
+      else reject(new Error(`${h.label} exited ${code}${stderr ? `\n  ${stderr.trim().split('\n').slice(-3).join('\n  ')}` : ''}`));
+    });
+    child.on('error', (e) => reject(new Error(`Could not run ${h.bin}: ${e.message}`)));
+  });
+}
+
+module.exports = { HARNESSES, isInstalled, detectInstalled, listHarnesses, runViaHarness };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phewsh",
-  "version": "0.12.1",
+  "version": "0.12.3",
   "description": "Turn intent into action. Structure your thinking, execute your next step.",
   "bin": {
     "phewsh": "bin/phewsh.js"