specdacular 0.12.1 → 0.13.1

package/bin/specd.js

@@ -3,23 +3,22 @@
 // bin/specd.js — unified CLI entry point
 // Usage:
 //   specd llm-init [--local]        — install commands/agents/workflows
-//   specd install-runner             — install runner dependencies (express, ws, electron)
-//   specd runner                     — launch Electron app
+//   specd install-runner             — download Specd Runner app from GitHub Releases
+//   specd runner                     — launch Specd Runner app
 //   specd runner register <path>     — register a folder
 //   specd runner unregister <id>     — remove a project
 //   specd runner projects            — list projects
 //   specd runner status              — show task status
 
 import { resolve, join } from 'path';
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { homedir, platform } from 'os';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, createWriteStream, unlinkSync } from 'fs';
+import { homedir, platform, arch } from 'os';
 import { execSync, spawn } from 'child_process';
+import { get } from 'https';
 
 const args = process.argv.slice(2);
 const command = args[0];
 
-const runnerDir = join(import.meta.dirname, '..', 'runner');
-
 function getAppDataDir() {
   if (platform() === 'darwin') {
     return join(homedir(), 'Library', 'Application Support', 'Specd');
@@ -27,6 +26,27 @@ function getAppDataDir() {
   return join(homedir(), '.config', 'specd');
 }
 
+function getAppInstallDir() {
+  if (platform() === 'darwin') {
+    return '/Applications';
+  }
+  return join(getAppDataDir(), 'app');
+}
+
+function getRunnerAppPath() {
+  if (platform() === 'darwin') {
+    return join(getAppInstallDir(), 'Specd Runner.app');
+  }
+  if (platform() === 'linux') {
+    return join(getAppInstallDir(), 'Specd Runner.AppImage');
+  }
+  return join(getAppInstallDir(), 'Specd Runner.exe');
+}
+
+function isRunnerInstalled() {
+  return existsSync(getRunnerAppPath());
+}
+
 function getDbPath() {
   return join(getAppDataDir(), 'db.json');
 }
@@ -43,15 +63,139 @@ function saveDb(data) {
   writeFileSync(dbPath, JSON.stringify(data, null, 2));
 }
 
-function isRunnerInstalled() {
-  return existsSync(join(runnerDir, 'node_modules', 'express'));
+function fetchJson(url) {
+  return new Promise((resolve, reject) => {
+    get(url, { headers: { 'User-Agent': 'specd-cli' } }, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        return fetchJson(res.headers.location).then(resolve, reject);
+      }
+      let data = '';
+      res.on('data', (chunk) => data += chunk);
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); }
+        catch (e) { reject(new Error(`Failed to parse response: ${data.slice(0, 200)}`)); }
+      });
+    }).on('error', reject);
+  });
 }
 
-function requireRunner() {
-  if (!isRunnerInstalled()) {
-    console.error('Runner dependencies not installed. Run: specd install-runner');
+function download(url, dest) {
+  return new Promise((resolve, reject) => {
+    const follow = (url) => {
+      get(url, { headers: { 'User-Agent': 'specd-cli' } }, (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          return follow(res.headers.location);
+        }
+        if (res.statusCode !== 200) {
+          return reject(new Error(`Download failed: HTTP ${res.statusCode}`));
+        }
+        const total = parseInt(res.headers['content-length'], 10);
+        let downloaded = 0;
+        const file = createWriteStream(dest);
+        res.on('data', (chunk) => {
+          downloaded += chunk.length;
+          if (total) {
+            const pct = Math.round(downloaded / total * 100);
+            process.stdout.write(`\rDownloading... ${pct}%`);
+          }
+        });
+        res.pipe(file);
+        file.on('finish', () => {
+          file.close();
+          console.log('\rDownload complete.        ');
+          resolve();
+        });
+      }).on('error', reject);
+    };
+    follow(url);
+  });
+}
+
+async function installRunner() {
+  const os = platform();
+  const cpuArch = arch();
+
+  console.log(`Fetching latest Specd Runner release...`);
+
+  const release = await fetchJson(
+    'https://api.github.com/repos/victorbalan/specdacular/releases/latest'
+  ).catch(() => null);
+
+  // Also check for runner-specific tags
+  const releases = await fetchJson(
+    'https://api.github.com/repos/victorbalan/specdacular/releases?per_page=10'
+  ).catch(() => []);
+
+  const runnerRelease = releases.find(r => r.tag_name?.startsWith('runner-v')) || release;
+
+  if (!runnerRelease || !runnerRelease.assets?.length) {
+    console.error('No runner release found. The Specd Runner app has not been published yet.');
+    console.error('For local development, run from the repo: cd runner && npm install && npm run dev');
+    process.exit(1);
+  }
+
+  // Find the right asset for this platform
+  let assetName;
+  if (os === 'darwin') {
+    // Prefer dmg, fall back to zip
+    const dmg = runnerRelease.assets.find(a => a.name.endsWith('.dmg') && (
+      a.name.includes('arm64') ? cpuArch === 'arm64' : cpuArch === 'x64'
+    ));
+    const universalDmg = runnerRelease.assets.find(a => a.name.endsWith('.dmg') && a.name.includes('universal'));
+    const anyDmg = runnerRelease.assets.find(a => a.name.endsWith('.dmg'));
+    assetName = dmg || universalDmg || anyDmg;
+  } else if (os === 'linux') {
+    assetName = runnerRelease.assets.find(a => a.name.endsWith('.AppImage'));
+  } else if (os === 'win32') {
+    assetName = runnerRelease.assets.find(a => a.name.endsWith('.exe'));
+  }
+
+  if (!assetName) {
+    console.error(`No runner build found for ${os}/${cpuArch}.`);
+    console.error('Available assets:', runnerRelease.assets.map(a => a.name).join(', '));
     process.exit(1);
   }
+
+  const tmpDir = join(getAppDataDir(), 'tmp');
+  mkdirSync(tmpDir, { recursive: true });
+  const tmpFile = join(tmpDir, assetName.name);
+
+  console.log(`Downloading ${assetName.name} (${(assetName.size / 1024 / 1024).toFixed(1)} MB)...`);
+  await download(assetName.browser_download_url, tmpFile);
+
+  if (os === 'darwin') {
+    if (assetName.name.endsWith('.dmg')) {
+      console.log('Mounting DMG and copying app...');
+      const mountOutput = execSync(`hdiutil attach "${tmpFile}" -nobrowse -quiet`, { encoding: 'utf-8' });
+      const mountPoint = mountOutput.trim().split('\t').pop().trim();
+
+      try {
+        execSync(`cp -R "${mountPoint}/Specd Runner.app" "/Applications/"`, { stdio: 'pipe' });
+      } finally {
+        execSync(`hdiutil detach "${mountPoint}" -quiet`, { stdio: 'pipe' });
+      }
+    } else {
+      // zip
+      execSync(`unzip -o "${tmpFile}" -d "/Applications/"`, { stdio: 'pipe' });
+    }
+    console.log('Specd Runner installed to /Applications/Specd Runner.app');
+  } else if (os === 'linux') {
+    const installDir = getAppInstallDir();
+    mkdirSync(installDir, { recursive: true });
+    const dest = join(installDir, 'Specd Runner.AppImage');
+    execSync(`cp "${tmpFile}" "${dest}" && chmod +x "${dest}"`);
+    console.log(`Specd Runner installed to ${dest}`);
+  } else {
+    const installDir = getAppInstallDir();
+    mkdirSync(installDir, { recursive: true });
+    execSync(`cp "${tmpFile}" "${join(installDir, 'Specd Runner.exe')}"`);
+    console.log(`Specd Runner installed to ${installDir}`);
+  }
+
+  // Cleanup
+  try { unlinkSync(tmpFile); } catch {}
+
+  console.log('Done! Run: specd runner');
 }
 
 if (command === 'llm-init') {
@@ -61,19 +205,7 @@ if (command === 'llm-init') {
   await import(installScript);
 
 } else if (command === 'install-runner') {
-  console.log('Installing runner dependencies...');
-  execSync('npm install --omit=dev', { cwd: runnerDir, stdio: 'inherit' });
-
-  // Also install renderer deps and build
-  const rendererDir = join(runnerDir, 'renderer');
-  if (existsSync(join(rendererDir, 'package.json'))) {
-    console.log('Installing renderer dependencies...');
-    execSync('npm install', { cwd: rendererDir, stdio: 'inherit' });
-    console.log('Building renderer...');
-    execSync('npm run build', { cwd: rendererDir, stdio: 'inherit' });
-  }
-
-  console.log('Runner installed. Run: specd runner');
+  await installRunner();
 
 } else if (command === 'runner') {
   const subcommand = args[1];
@@ -133,26 +265,26 @@ if (command === 'llm-init') {
       console.error('Runner not running. Start it with: specd runner');
     }
   } else {
-    // No subcommand — launch Electron app
-    requireRunner();
-
-    const electronPath = join(runnerDir, 'node_modules', '.bin', 'electron');
-    if (!existsSync(electronPath)) {
-      console.error('Electron not installed. Run: specd install-runner');
+    // No subcommand — launch the app
+    if (!isRunnerInstalled()) {
+      console.error('Specd Runner not installed. Run: specd install-runner');
       process.exit(1);
     }
 
-    const child = spawn(electronPath, [runnerDir], {
-      detached: true,
-      stdio: 'ignore',
-    });
-    child.unref();
+    const appPath = getRunnerAppPath();
+    if (platform() === 'darwin') {
+      spawn('open', ['-a', appPath], { detached: true, stdio: 'ignore' }).unref();
+    } else if (platform() === 'linux') {
+      spawn(appPath, [], { detached: true, stdio: 'ignore' }).unref();
+    } else {
+      spawn(appPath, [], { detached: true, stdio: 'ignore' }).unref();
+    }
     console.log('Specd Runner launched.');
   }
 } else {
   console.log('Usage:');
   console.log('  specd llm-init [--local]      Install Claude Code commands/agents');
-  console.log('  specd install-runner           Install runner dependencies');
+  console.log('  specd install-runner           Download and install the Specd Runner app');
   console.log('  specd runner                   Launch the Specd Runner app');
   console.log('  specd runner register <path>   Register a project folder');
   console.log('  specd runner unregister <id>   Remove a project');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specdacular",
-  "version": "0.12.1",
+  "version": "0.13.1",
   "description": "Feature planning system for existing codebases. Map, understand, and plan features in large projects.",
   "bin": {
     "specd": "bin/specd.js"
@@ -11,10 +11,6 @@
     "agents",
     "specdacular",
     "hooks",
-    "runner/main",
-    "runner/renderer/dist",
-    "runner/preload.js",
-    "runner/package.json",
     "README.md"
   ],
   "keywords": [

package/runner/main/agent/parser.js

@@ -1,39 +0,0 @@
-import { EventEmitter } from 'events';
-
-export class StreamParser extends EventEmitter {
-  constructor() {
-    super();
-    this.inBlock = null;
-    this.blockLines = [];
-  }
-
-  feed(line) {
-    if (line.startsWith('```specd-status')) {
-      this.inBlock = 'status';
-      this.blockLines = [];
-      return;
-    }
-    if (line.startsWith('```specd-result')) {
-      this.inBlock = 'result';
-      this.blockLines = [];
-      return;
-    }
-    if (line === '```' && this.inBlock) {
-      const content = this.blockLines.join('\n');
-      try {
-        const parsed = JSON.parse(content);
-        this.emit(this.inBlock, parsed);
-      } catch (err) {
-        this.emit('error', err);
-      }
-      this.inBlock = null;
-      this.blockLines = [];
-      return;
-    }
-    if (this.inBlock) {
-      this.blockLines.push(line);
-    } else {
-      this.emit('output', line);
-    }
-  }
-}

package/runner/main/agent/runner.js

@@ -1,137 +0,0 @@
-import { spawn } from 'child_process';
-import { EventEmitter } from 'events';
-import { createWriteStream } from 'fs';
-import { StreamParser } from './parser.js';
-
-export class AgentRunner extends EventEmitter {
-  constructor({ cmd, input_mode, output_format, system_prompt, timeout, stuck_timeout }) {
-    super();
-    this.cmd = cmd;
-    this.inputMode = input_mode || 'stdin';
-    this.outputFormat = output_format || 'stream_json';
-    this.systemPrompt = system_prompt || '';
-    this.timeout = (timeout || 3600) * 1000;
-    this.stuckTimeout = (stuck_timeout || 1800) * 1000;
-  }
-
-  async run(prompt, { cwd, logPath } = {}) {
-    return new Promise((resolve, reject) => {
-      const fullPrompt = this.systemPrompt ? `${this.systemPrompt}\n\n${prompt}` : prompt;
-      const args = this.cmd.split(' ').slice(1);
-      const bin = this.cmd.split(' ')[0];
-
-      const proc = spawn(bin, args, {
-        cwd,
-        shell: true,
-        stdio: ['pipe', 'pipe', 'pipe'],
-        env: { ...process.env },
-      });
-
-      const logStream = logPath ? createWriteStream(logPath, { flags: 'a' }) : null;
-      let lastOutputAt = Date.now();
-      let result = null;
-
-      const parser = new StreamParser();
-      parser.on('status', (s) => {
-        lastOutputAt = Date.now();
-        this.emit('status', s);
-      });
-      parser.on('result', (r) => {
-        lastOutputAt = Date.now();
-        result = r;
-        this.emit('result', r);
-      });
-      parser.on('output', (line) => {
-        lastOutputAt = Date.now();
-        this.emit('output', line);
-      });
-
-      const handleLine = (line) => {
-        if (logStream) logStream.write(line + '\n');
-
-        if (this.outputFormat === 'stream_json') {
-          try {
-            const event = JSON.parse(line);
-            if (event.type === 'assistant' && event.message?.content) {
-              for (const block of event.message.content) {
-                if (block.type === 'text') {
-                  for (const textLine of block.text.split('\n')) {
-                    parser.feed(textLine);
-                  }
-                }
-              }
-            } else if (event.type === 'result' && event.result) {
-              for (const block of event.result) {
-                if (block.type === 'text') {
-                  for (const textLine of block.text.split('\n')) {
-                    parser.feed(textLine);
-                  }
-                }
-              }
-            }
-          } catch {
-            parser.feed(line);
-          }
-        } else {
-          parser.feed(line);
-        }
-      };
-
-      let stdout = '';
-      proc.stdout.on('data', (chunk) => {
-        stdout += chunk.toString();
-        const lines = stdout.split('\n');
-        stdout = lines.pop();
-        for (const line of lines) {
-          if (line.trim()) handleLine(line.trim());
-        }
-      });
-
-      proc.stderr.on('data', (chunk) => {
-        if (logStream) logStream.write(`[stderr] ${chunk}`);
-      });
-
-      if (this.inputMode === 'stdin') {
-        proc.stdin.write(fullPrompt);
-        proc.stdin.end();
-      }
-
-      // Global timeout
-      const globalTimer = setTimeout(() => {
-        proc.kill('SIGTERM');
-        setTimeout(() => proc.kill('SIGKILL'), 5000);
-      }, this.timeout);
-
-      // Stuck detection
-      const stuckCheck = setInterval(() => {
-        if (Date.now() - lastOutputAt > this.stuckTimeout) {
-          this.emit('error', new Error('Agent stuck — no output'));
-          proc.kill('SIGTERM');
-          setTimeout(() => proc.kill('SIGKILL'), 5000);
-        }
-      }, 30000);
-
-      proc.on('close', (code) => {
-        clearTimeout(globalTimer);
-        clearInterval(stuckCheck);
-        if (logStream) logStream.end();
-        if (stdout.trim()) handleLine(stdout.trim());
-
-        if (result) {
-          resolve(result);
-        } else if (code === 0) {
-          resolve({ status: 'success', summary: 'Agent completed without explicit result' });
-        } else {
-          resolve({ status: 'failure', summary: `Agent exited with code ${code}` });
-        }
-      });
-
-      proc.on('error', (err) => {
-        clearTimeout(globalTimer);
-        clearInterval(stuckCheck);
-        if (logStream) logStream.end();
-        reject(err);
-      });
-    });
-  }
-}

package/runner/main/agent/template.js

@@ -1,16 +0,0 @@
-export function resolveTemplate(template, variables) {
-  return template.replace(/\{\{([^}]+)\}\}/g, (match, path) => {
-    const value = path.trim().split('.').reduce((obj, key) => obj?.[key], variables);
-    return value !== undefined ? String(value) : match;
-  });
-}
-
-export function buildTemplateContext(task, stage, pipeline, paths) {
-  return {
-    task: { id: task.id, name: task.name, spec: task.spec || '' },
-    stage: { name: stage.stage, index: stage.index, total: stage.total },
-    pipeline: { name: pipeline.name },
-    status_file: paths?.statusJson || '',
-    log_dir: paths?.logsDir || '',
-  };
-}

package/runner/main/bootstrap.js

@@ -1,69 +0,0 @@
-import { mkdirSync, writeFileSync, existsSync } from 'fs';
-import { join } from 'path';
-
-const DEFAULT_CONFIG = {
-  server: { port: 3700 },
-  notifications: { telegram: { enabled: false } },
-  defaults: {
-    pipeline: 'default',
-    failure_policy: 'skip',
-    timeout: 3600,
-    stuck_timeout: 1800,
-    max_parallel: 1,
-  },
-};
-
-const DEFAULT_AGENTS = {
-  'claude-planner': {
-    cmd: 'claude -p --dangerously-skip-permissions',
-    input_mode: 'stdin',
-    output_format: 'stream_json',
-    system_prompt: 'You are a feature planner working on: {{task.name}} ({{task.id}})\nPipeline: {{pipeline.name}} | Stage: {{stage.name}} ({{stage.index}}/{{stage.total}})\n\nResearch the codebase thoroughly, then create a detailed implementation plan.\n\nEmit progress:\n```specd-status\n{"task_id":"{{task.id}}","stage":"{{stage.name}}","progress":"...","percent":0}\n```\n\nWhen done:\n```specd-result\n{"status":"success","summary":"...","files_changed":[],"issues":[]}\n```',
-  },
-  'claude-implementer': {
-    cmd: 'claude -p --dangerously-skip-permissions',
-    input_mode: 'stdin',
-    output_format: 'stream_json',
-    system_prompt: 'You are an implementer working on: {{task.name}} ({{task.id}})\nPipeline: {{pipeline.name}} | Stage: {{stage.name}} ({{stage.index}}/{{stage.total}})\n\nImplement the plan from the previous stage. Write clean, tested code.\n\nEmit progress:\n```specd-status\n{"task_id":"{{task.id}}","stage":"{{stage.name}}","progress":"...","percent":0}\n```\n\nWhen done:\n```specd-result\n{"status":"success","summary":"...","files_changed":[],"issues":[]}\n```',
-  },
-  'claude-reviewer': {
-    cmd: 'claude -p --dangerously-skip-permissions',
-    input_mode: 'stdin',
-    output_format: 'stream_json',
-    system_prompt: 'You are a code reviewer for: {{task.name}} ({{task.id}})\nPipeline: {{pipeline.name}} | Stage: {{stage.name}} ({{stage.index}}/{{stage.total}})\n\nReview the implementation from the previous stage. Check for bugs, style, tests.\n\nEmit progress:\n```specd-status\n{"task_id":"{{task.id}}","stage":"{{stage.name}}","progress":"...","percent":0}\n```\n\nWhen done:\n```specd-result\n{"status":"success","summary":"...","files_changed":[],"issues":[]}\n```',
-  },
-};
-
-const DEFAULT_PIPELINE = {
-  name: 'default',
-  stages: [
-    { stage: 'plan', agent: 'claude-planner', critical: true },
-    { stage: 'implement', agent: 'claude-implementer', critical: true },
-    { stage: 'review', agent: 'claude-reviewer', on_fail: 'retry', max_retries: 2 },
-  ],
-};
-
-function writeIfMissing(filePath, data) {
-  if (!existsSync(filePath)) {
-    writeFileSync(filePath, JSON.stringify(data, null, 2));
-  }
-}
-
-export async function bootstrap(paths) {
-  // Create directories
-  mkdirSync(paths.agentTemplatesDir, { recursive: true });
-  mkdirSync(paths.pipelineTemplatesDir, { recursive: true });
-  mkdirSync(paths.projectsDir, { recursive: true });
-
-  // Write default files
-  writeIfMissing(paths.db, { projects: [] });
-  writeIfMissing(paths.config, DEFAULT_CONFIG);
-
-  // Write default agent templates
-  for (const [name, agent] of Object.entries(DEFAULT_AGENTS)) {
-    writeIfMissing(join(paths.agentTemplatesDir, `${name}.json`), agent);
-  }
-
-  // Write default pipeline template
-  writeIfMissing(join(paths.pipelineTemplatesDir, 'default.json'), DEFAULT_PIPELINE);
-}

package/runner/main/db.js

@@ -1,45 +0,0 @@
-import { readFileSync, writeFileSync } from 'fs';
-import { randomUUID } from 'crypto';
-
-export class ProjectDB {
-  constructor(dbPath) {
-    this.dbPath = dbPath;
-    this.data = JSON.parse(readFileSync(dbPath, 'utf-8'));
-  }
-
-  register(name, folderPath) {
-    const project = {
-      id: randomUUID().slice(0, 8),
-      name,
-      path: folderPath,
-      active: true,
-      registeredAt: new Date().toISOString(),
-    };
-    this.data.projects.push(project);
-    this._save();
-    return project;
-  }
-
-  unregister(id) {
-    this.data.projects = this.data.projects.filter(p => p.id !== id);
-    this._save();
-  }
-
-  get(id) {
-    return this.data.projects.find(p => p.id === id) || null;
-  }
-
-  findByPath(folderPath) {
-    return this.data.projects.find(p =>
-      folderPath === p.path || folderPath.startsWith(p.path + '/')
-    ) || null;
-  }
-
-  list() {
-    return this.data.projects;
-  }
-
-  _save() {
-    writeFileSync(this.dbPath, JSON.stringify(this.data, null, 2));
-  }
-}