phewsh 0.12.2 → 0.12.4

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:

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/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/lib/supabase.js

@@ -1,7 +1,7 @@
 // Supabase REST client for the CLI — no SDK, just fetch (Node 18+ built-in)
 
 const SUPABASE_URL = 'https://fpnpfnahwaztdlxuayyv.supabase.co';
-const SUPABASE_ANON_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImZwbnBmbmFod2F6dGRseHVheXl2Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjA1NDY2NTcsImV4cCI6MjA3NjEyMjY1N30.Q6mn8RIvXujBXbd10aFkeY7yGHVsAQPEHM5OzoPMsFQ';
+const SUPABASE_ANON_KEY = 'sb_publishable_sL3R5aB43Yo5Ct0NQwB4fg_je9ccSHY';
 
 async function req(path, options = {}, accessToken = null) {
   const headers = {

package/package.json

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