runwork 0.9.1 → 0.9.3

package/dist/commands/sync.js

@@ -4,7 +4,7 @@ import { join } from 'path';
 import { homedir } from 'os';
 import { requireAuth } from '../auth/store.js';
 import { ApiClient } from '../api/client.js';
-import { getAdapterBySlug } from '../agents/detect.js';
+import { getAdapterBySlug, detectAgents } from '../agents/detect.js';
 import { CodexAdapter } from '../agents/codex.js';
 import { RUNWORK_MCP_PREFIX, RUNWORK_WORKSPACE_MCP_NAME } from '../agents/types.js';
 import { collectTelemetryEvents, printTelemetryVerbose, summarizeTelemetryForDryRun, } from './sync-telemetry.js';
@@ -60,6 +60,49 @@ function readLocalSkills(state) {
     }
     return results;
 }
+/**
+ * How long a detection result stays trusted before sync re-runs detection
+ * on its own. Detection is cheap on macOS/Linux but pays a PowerShell
+ * waterfall on Windows, so we cache for a day. Users who just installed
+ * a new agent can shortcut the wait via `--redetect` (or the desktop's
+ * "Rescan" button, which forwards the flag).
+ */
+export const REDETECT_TTL_MS = 24 * 60 * 60 * 1000;
+/**
+ * Decide whether to re-run installation detection for this sync. We always
+ * re-detect on explicit user request, on first sync (no timestamp yet), when
+ * setup ended up with zero agents (recovery), or after the TTL has lapsed.
+ */
+export function shouldRedetect(state, opts) {
+    if (opts.redetect)
+        return true;
+    if (state.configuredAgents.length === 0)
+        return true;
+    if (!state.lastDetectedAt)
+        return true;
+    const last = Date.parse(state.lastDetectedAt);
+    if (Number.isNaN(last))
+        return true;
+    return Date.now() - last > REDETECT_TTL_MS;
+}
+/**
+ * Detect installed agents and merge any new slugs into `state.configuredAgents`.
+ * Never removes agents — a transient PATH glitch shouldn't wipe the setup.
+ * Returns the slugs that were newly added (for logging).
+ */
+export async function refreshConfiguredAgents(state) {
+    const detected = await detectAgents();
+    const before = new Set(state.configuredAgents);
+    const added = [];
+    for (const adapter of detected) {
+        if (!before.has(adapter.slug)) {
+            state.configuredAgents.push(adapter.slug);
+            added.push(adapter.slug);
+        }
+    }
+    state.lastDetectedAt = new Date().toISOString();
+    return added;
+}
 export async function syncFromState(state, statePath, credentials, opts) {
     const client = new ApiClient(credentials);
     // Refresh workspace name/slug if missing or stale (e.g. setup ran before name was set)
@@ -77,6 +120,16 @@ export async function syncFromState(state, statePath, credentials, opts) {
         }
     }
     console.log(`Syncing workspace: ${state.workspaceName || state.workspaceId}`);
+    // Refresh the configured-agents list when the cached detection is stale,
+    // empty, or the user explicitly asked. This is what catches "I just installed
+    // Claude Code on this machine" without needing the user to re-run setup.
+    if (shouldRedetect(state, opts)) {
+        console.log('  Detecting installed agents...');
+        const added = await refreshConfiguredAgents(state);
+        if (added.length > 0) {
+            console.log(`  Detected new agent${added.length > 1 ? 's' : ''}: ${added.join(', ')}`);
+        }
+    }
     console.log('  Fetching workspace data...');
     // Fetch latest data (includeContent=true gets all skill content in one request)
     const [allSkills, mcpServers, externalSkills, registries, connectedIntegrations] = await Promise.all([
@@ -436,6 +489,7 @@ export const syncCommand = new Command('sync')
     .option('--pull-only', 'Only pull remote changes, never push local edits')
     .option('--prefer <side>', 'Auto-resolve conflicts: "local" or "remote" (implies --yes)')
     .option('-y, --yes', 'Non-interactive mode (default: prefer remote for conflicts)')
+    .option('--redetect', 'Force agent-installation re-detection (picks up agents installed since last setup)')
     .action(async (opts) => {
     const credentials = requireAuth();
     const syncOpts = {
@@ -444,6 +498,7 @@ export const syncCommand = new Command('sync')
         yes: !!opts.yes || !!opts.prefer,
         prefer: opts.prefer,
         verbose: !!opts.verbose,
+        redetect: !!opts.redetect,
     };
     const projectStatePath = join(process.cwd(), '.runwork', 'setup.json');
     const userStatePath = join(homedir(), '.runwork', 'setup.json');

package/dist/devtools/registry-data.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Developer tool registry — non-AI prerequisites Runwork users need installed
+ * locally (git today, more later if needed).
+ *
+ * Extends the shared `InstallableTool` base so the desktop can detect and
+ * render devtools alongside AI agents using the same icon/detection plumbing.
+ *
+ * Browser-safe: no node-only imports.
+ */
+import type { InstallableTool } from '../tools/types.js';
+/**
+ * How the desktop should attempt to install the tool. Each platform either
+ * has an automated install command (run via the platform shell) or falls
+ * back to opening the tool's `downloadUrl` in the browser.
+ */
+export type DevToolInstallStrategy = {
+    kind: 'shell';
+    shell: 'powershell' | 'zsh' | 'bash';
+    command: string;
+    postInstallNote?: string;
+} | {
+    kind: 'open-url';
+    url: string;
+};
+export interface DevToolDefinition extends InstallableTool {
+    /** Beginner-friendly explanation shown in the install card. */
+    longDescription: string;
+    /**
+     * Per-platform install strategy. Missing platforms fall back to opening
+     * `downloadUrl` in the browser.
+     */
+    install: {
+        macos?: DevToolInstallStrategy;
+        windows?: DevToolInstallStrategy;
+        linux?: DevToolInstallStrategy;
+    };
+}
+export declare function getDevTools(): DevToolDefinition[];
+export declare function getDevTool(slug: string): DevToolDefinition | undefined;

package/dist/devtools/registry-data.js

@@ -0,0 +1,39 @@
+/**
+ * Developer tool registry — non-AI prerequisites Runwork users need installed
+ * locally (git today, more later if needed).
+ *
+ * Extends the shared `InstallableTool` base so the desktop can detect and
+ * render devtools alongside AI agents using the same icon/detection plumbing.
+ *
+ * Browser-safe: no node-only imports.
+ */
+const DEV_TOOL_REGISTRY = [
+    {
+        slug: 'git',
+        name: 'Git',
+        description: 'Version control system',
+        longDescription: 'Git tracks changes to your code and is required for Runwork commands that sync your work with the platform (init, clone, dev, deploy).',
+        detection: { method: 'binary', target: 'git' },
+        downloadUrl: 'https://git-scm.com/downloads',
+        install: {
+            windows: {
+                kind: 'shell',
+                shell: 'powershell',
+                command: 'winget install --id Git.Git -e --source winget --accept-package-agreements --accept-source-agreements',
+            },
+            macos: {
+                kind: 'shell',
+                shell: 'zsh',
+                command: 'xcode-select --install',
+                postInstallNote: 'A macOS installer window has opened. Finish the install there, then click Re-detect.',
+            },
+            linux: { kind: 'open-url', url: 'https://git-scm.com/download/linux' },
+        },
+    },
+];
+export function getDevTools() {
+    return DEV_TOOL_REGISTRY;
+}
+export function getDevTool(slug) {
+    return DEV_TOOL_REGISTRY.find((t) => t.slug === slug);
+}

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.9.1";
+export declare const VERSION = "0.9.3";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/embed-types.ts -- do not edit
-export const VERSION = "0.9.1";
+export const VERSION = "0.9.3";

package/dist/git/__tests__/manifest.test.js

@@ -67,6 +67,47 @@ describe('generateManifest()', () => {
         expect(Object.keys(manifest.files)).toHaveLength(1);
         expect(manifest.files['a.txt']).toBeDefined();
     });
+    it('skips .bun-cache directory by default (regression: hung dev startup)', async () => {
+        // Bun's per-project cache used to be walked recursively here. When it
+        // grew to ~1 GB / 25k+ files, generateManifest spent minutes hashing
+        // every file and starved the rest of `runwork dev`. The default
+        // ignore-matcher now skips .bun-cache/ even without a .gitignore.
+        const dir = makeTempDir('bun-cache');
+        writeFileSync(join(dir, 'a.txt'), 'hello');
+        mkdirSync(join(dir, '.bun-cache'));
+        writeFileSync(join(dir, '.bun-cache', 'pkg.tgz'), 'tarball');
+        mkdirSync(join(dir, '.bun-cache', 'react@19.0.0'));
+        writeFileSync(join(dir, '.bun-cache', 'react@19.0.0', 'index.js'), 'r');
+        const manifest = await generateManifest(dir);
+        expect(Object.keys(manifest.files)).toEqual(['a.txt']);
+    });
+    it('honors simple .gitignore directory entries (e.g. dist/, .next/, coverage)', async () => {
+        const dir = makeTempDir('gitignored-dirs');
+        writeFileSync(join(dir, '.gitignore'), 'dist/\n.next/\ncoverage\n');
+        writeFileSync(join(dir, 'a.txt'), 'hello');
+        mkdirSync(join(dir, 'dist'));
+        writeFileSync(join(dir, 'dist', 'bundle.js'), 'compiled');
+        mkdirSync(join(dir, '.next'));
+        writeFileSync(join(dir, '.next', 'build.json'), '{}');
+        mkdirSync(join(dir, 'coverage'));
+        writeFileSync(join(dir, 'coverage', 'lcov.info'), 'data');
+        const manifest = await generateManifest(dir);
+        const keys = Object.keys(manifest.files).sort();
+        expect(keys).toEqual(['.gitignore', 'a.txt']);
+    });
+    it('falls through to defaults when .gitignore patterns are too complex', async () => {
+        // The walker only honors simple directory/basename entries. Globbed
+        // patterns are skipped, so files matching them still appear in the
+        // manifest. This is acceptable: the goal is to avoid the runaway
+        // cases (huge gitignored caches), not to be a full gitignore matcher.
+        const dir = makeTempDir('complex-gitignore');
+        writeFileSync(join(dir, '.gitignore'), '*.local\nsrc/generated/\n');
+        writeFileSync(join(dir, 'a.txt'), 'hello');
+        writeFileSync(join(dir, 'config.local'), 'should-still-appear');
+        const manifest = await generateManifest(dir);
+        expect(manifest.files['a.txt']).toBeDefined();
+        expect(manifest.files['config.local']).toBeDefined();
+    });
     it('handles files with spaces in names', async () => {
         const dir = makeTempDir('spaces');
         writeFileSync(join(dir, 'hello world.txt'), 'content');
@@ -374,4 +415,32 @@ describe('detectUserEdits() edge cases', () => {
         const edits = await detectUserEdits(dir, manifest);
         expect(edits).not.toContain('config.txt');
     });
+    it('does not flag tracked file whose committed content differs from template manifest', async () => {
+        // Reproduces the post-`runwork clone` scenario: the manifest was
+        // generated from the pristine template, then the AI-customized
+        // version was overlaid via `git fetch` + `git checkout .` and is now
+        // committed at HEAD with no local edits. Method 3's scan would
+        // false-flag every such file on every clone if it didn't skip
+        // tracked files.
+        const dir = makeTempDir('clone-overlay');
+        initGitRepo(dir);
+        // Simulate: AI-customized version is committed at HEAD.
+        const overlaidContent = 'AI-customized content';
+        writeFileSync(join(dir, 'worker/agents.ts'.replace('/', '-')), 'placeholder');
+        const aiFilePath = 'agents.ts';
+        writeFileSync(join(dir, aiFilePath), overlaidContent);
+        execFileSync('git', ['add', '.'], { cwd: dir });
+        execFileSync('git', ['commit', '-m', 'overlay'], { cwd: dir });
+        // Manifest captured the PRISTINE template hash (different from the
+        // overlaid HEAD content). detectUserEdits must not treat this as a
+        // user edit.
+        const manifest = {
+            version: 1,
+            files: {
+                [aiFilePath]: 'sha256:pristine_template_hash_unrelated_to_disk',
+            },
+        };
+        const edits = await detectUserEdits(dir, manifest);
+        expect(edits).not.toContain(aiFilePath);
+    });
 });

package/dist/git/auto-commit.d.ts

@@ -1,4 +1,9 @@
 import type { ApiClient } from '../api/client.js';
+/**
+ * Basename-level ignore predicate using the static defaults only.
+ * Exposed for unit testing of the static defaults; the runtime watcher uses
+ * a richer matcher built from `.gitignore` (see watchAndAutoCommit).
+ */
 export declare function isIgnored(filePath: string): boolean;
 export declare function watchAndAutoCommit(directory: string, client: ApiClient, appId: string, callbacks?: {
     onFileChange?: (relPath: string, pendingCount: number) => void;

package/dist/git/auto-commit.js

@@ -1,8 +1,9 @@
 import { execFileSync } from 'child_process';
 import { readFileSync } from 'fs';
 import { watch } from 'chokidar';
-import { basename, join, relative } from 'path';
+import { join, relative } from 'path';
 import { dim, cyan, yellow } from '../ui/colors.js';
+import { buildIgnoreSets, defaultIgnoreSets, isPathIgnored } from '../utils/ignore-matcher.js';
 let watcher = null;
 let fastSyncTimer = null;
 let gitTimer = null;
@@ -13,9 +14,6 @@ let activeCallbacks;
 const pendingFastSync = new Map();
 // Track files the user actually touched during this session (for git)
 const changedFiles = new Set();
-const SKIP_DIRS = new Set(['node_modules', '.git', '.runwork']);
-const SKIP_FILES = new Set(['.dev.vars', '.env']);
-const SKIP_EXTENSIONS = new Set(['.log']);
 // Binary extensions to skip in fast sync (git handles them fine)
 const BINARY_EXTENSIONS = new Set([
     '.png', '.jpg', '.jpeg', '.gif', '.ico', '.webp', '.avif', '.svg',
@@ -24,21 +22,24 @@ const BINARY_EXTENSIONS = new Set([
     '.zip', '.tar', '.gz', '.br',
     '.pdf', '.wasm',
 ]);
+const STATIC_IGNORE_SETS = defaultIgnoreSets();
+/**
+ * Basename-level ignore predicate using the static defaults only.
+ * Exposed for unit testing of the static defaults; the runtime watcher uses
+ * a richer matcher built from `.gitignore` (see watchAndAutoCommit).
+ */
 export function isIgnored(filePath) {
-    const name = basename(filePath);
-    if (SKIP_DIRS.has(name))
-        return true;
-    if (SKIP_FILES.has(name))
-        return true;
-    const ext = name.lastIndexOf('.') >= 0 ? name.slice(name.lastIndexOf('.')) : '';
-    if (SKIP_EXTENSIONS.has(ext))
-        return true;
-    return false;
+    return isPathIgnored(filePath, STATIC_IGNORE_SETS);
 }
 export async function watchAndAutoCommit(directory, client, appId, callbacks) {
     activeCallbacks = callbacks;
+    // Build a project-scoped ignore matcher that includes simple patterns from
+    // the project's .gitignore in addition to the static defaults. Without
+    // this the watcher tries to descend into large gitignored caches such as
+    // `.bun-cache/` or `dist/` and bogs the CLI down on startup.
+    const ignoreSets = buildIgnoreSets(directory);
     watcher = watch(directory, {
-        ignored: isIgnored,
+        ignored: (p) => isPathIgnored(p, ignoreSets),
         persistent: true,
         ignoreInitial: true,
         awaitWriteFinish: {

package/dist/git/credentials.js

@@ -6,11 +6,22 @@ import { getCredentials } from '../auth/store.js';
  */
 export async function configureGitCredentials(remoteUrl) {
     const origin = new URL(remoteUrl).origin;
-    execFileSync('git', [
-        'config', '--global',
-        `credential.${origin}.helper`,
-        '!runwork git-credential-helper',
-    ]);
+    try {
+        execFileSync('git', [
+            'config', '--global',
+            `credential.${origin}.helper`,
+            '!runwork git-credential-helper',
+        ], { stdio: 'pipe' });
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === 'ENOENT') {
+            console.warn('Note: git is not installed. Skipping git credential helper setup.');
+            console.warn('Install git before running `runwork init`, `clone`, `dev`, or `deploy`.');
+            return;
+        }
+        throw err;
+    }
 }
 /**
  * Remove the git credential helper configuration for our remote.

package/dist/template/manifest.js

@@ -2,22 +2,26 @@ import { createHash } from 'crypto';
 import { execFileSync } from 'child_process';
 import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync } from 'fs';
 import { join, relative } from 'path';
-const SKIP_DIRS = new Set(['.git', 'node_modules', '.runwork']);
-const SKIP_FILES = new Set(['.dev.vars', '.env']);
+import { buildIgnoreSets } from '../utils/ignore-matcher.js';
 function sha256(data) {
     return 'sha256:' + createHash('sha256').update(data).digest('hex');
 }
-function walkDir(dir, base) {
+function walkDir(dir, base, sets) {
     const results = [];
     const entries = readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-        if (SKIP_DIRS.has(entry.name))
+        if (sets.dirs.has(entry.name))
             continue;
-        if (SKIP_FILES.has(entry.name))
+        if (sets.files.has(entry.name))
             continue;
+        if (entry.isFile()) {
+            const dotIndex = entry.name.lastIndexOf('.');
+            if (dotIndex >= 0 && sets.extensions.has(entry.name.slice(dotIndex)))
+                continue;
+        }
         const fullPath = join(dir, entry.name);
         if (entry.isDirectory()) {
-            results.push(...walkDir(fullPath, base));
+            results.push(...walkDir(fullPath, base, sets));
         }
         else if (entry.isFile()) {
             results.push(relative(base, fullPath));
@@ -27,7 +31,8 @@ function walkDir(dir, base) {
 }
 export async function generateManifest(dir) {
     const files = {};
-    const allFiles = walkDir(dir, dir);
+    const sets = buildIgnoreSets(dir);
+    const allFiles = walkDir(dir, dir, sets);
     for (const relPath of allFiles) {
         const content = readFileSync(join(dir, relPath));
         files[relPath] = sha256(content);
@@ -104,9 +109,27 @@ export async function detectUserEdits(dir, manifest) {
     // 3. Scan manifest files on disk directly — catches gitignored files that
     // git ls-files --exclude-standard would miss. If a template file was added
     // to .gitignore by the user and then modified, only this check detects it.
+    //
+    // Tracked files are excluded here because their state is fully described
+    // by Method 1 (`git diff HEAD`). After `runwork clone`, AI-customized
+    // versions of template files are committed at HEAD and would otherwise be
+    // false-flagged on every fresh clone.
+    const trackedFiles = new Set();
+    try {
+        const tracked = execFileSync('git', ['-c', 'core.quotePath=false', 'ls-files'], { cwd: dir, encoding: 'utf-8' }).trim();
+        for (const relPath of tracked.split('\n')) {
+            if (relPath)
+                trackedFiles.add(relPath);
+        }
+    }
+    catch {
+        // No git repo — every manifest file remains a candidate for Method 3.
+    }
     for (const [relPath, expectedHash] of Object.entries(manifest.files)) {
         if (edits.includes(relPath))
             continue;
+        if (trackedFiles.has(relPath))
+            continue;
         const filePath = join(dir, relPath);
         try {
             const content = readFileSync(filePath);

package/dist/tools/types.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Shared types for everything Runwork can detect and offer to install
+ * locally. Both AI agents and developer prerequisites (git, etc.) extend
+ * `InstallableTool` so the desktop can render and detect them uniformly.
+ *
+ * Browser-safe: no node-only imports.
+ */
+/** Platform-specific string. Plain string = same on all platforms. */
+export type PlatformString = string | {
+    default?: string;
+    macos?: string;
+    windows?: string;
+    linux?: string;
+};
+/**
+ * Detection strategy. Supports simple binary/path checks plus richer
+ * Windows-specific methods and a nested `any` combinator for tools that
+ * ship as both GUI app and CLI binary.
+ */
+export type Detection = {
+    method: 'binary' | 'path';
+    target: PlatformString;
+} | {
+    method: 'windows-appx' | 'windows-start-app';
+    target: string | string[];
+} | {
+    method: 'any';
+    target: Detection[];
+};
+/**
+ * Common shape for anything that can be detected and installed locally.
+ * AI agents and developer tools both extend this.
+ */
+export interface InstallableTool {
+    /** Stable identifier, kebab-case (e.g. "claude-code", "git"). */
+    slug: string;
+    /** Display name. */
+    name: string;
+    /** One-line description shown in lists. */
+    description: string;
+    /** How to determine whether this tool is installed locally. */
+    detection: Detection;
+    /** Public install/download URL — universal fallback when auto-install isn't available. */
+    downloadUrl?: string;
+    /** Logo identifier (matches an entry in the desktop's logo map). Optional. */
+    logo?: string;
+}

package/dist/tools/types.js

@@ -0,0 +1,8 @@
+/**
+ * Shared types for everything Runwork can detect and offer to install
+ * locally. Both AI agents and developer prerequisites (git, etc.) extend
+ * `InstallableTool` so the desktop can render and detect them uniformly.
+ *
+ * Browser-safe: no node-only imports.
+ */
+export {};

package/dist/types.d.ts

@@ -141,6 +141,12 @@ export interface SetupState {
     }>;
     reportedAgentSlugs?: string[];
     lastHealthReportAt?: string;
+    /**
+     * ISO timestamp of the last agent-installation detection pass. Sync uses
+     * this with a TTL to skip the (Windows-expensive) PowerShell probe waterfall
+     * on every cycle while still catching newly-installed agents within a day.
+     */
+    lastDetectedAt?: string;
 }
 export interface WorkflowInfo {
     name: string;

package/dist/utils/__tests__/ignore-matcher.test.d.ts

@@ -0,0 +1 @@
+export {};