gsd-pi 2.10.11 → 2.11.0

package/dist/bundled-extension-paths.d.ts

@@ -0,0 +1,2 @@
+export declare function serializeBundledExtensionPaths(paths: readonly string[], pathDelimiter?: ";" | ":"): string;
+export declare function parseBundledExtensionPaths(value: string | undefined, pathDelimiter?: ";" | ":"): string[];

package/dist/bundled-extension-paths.js

@@ -0,0 +1,10 @@
+import { delimiter } from "node:path";
+export function serializeBundledExtensionPaths(paths, pathDelimiter = delimiter) {
+    return paths.filter(Boolean).join(pathDelimiter);
+}
+export function parseBundledExtensionPaths(value, pathDelimiter = delimiter) {
+    return (value ?? "")
+        .split(pathDelimiter)
+        .map((segment) => segment.trim())
+        .filter(Boolean);
+}

package/dist/loader.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { fileURLToPath } from 'url';
-import { dirname, resolve, join } from 'path';
-import { existsSync, readFileSync } from 'fs';
+import { dirname, resolve, join, delimiter } from 'path';
+import { existsSync, readFileSync, readdirSync, mkdirSync, symlinkSync } from 'fs';
 import { agentDir, appRoot } from './app-paths.js';
+import { serializeBundledExtensionPaths } from './bundled-extension-paths.js';
 import { renderLogo } from './logo.js';
 // pkg/ is a shim directory: contains gsd's piConfig (package.json) and pi's
 // theme assets (dist/modes/interactive/theme/) without a src/ directory.
@@ -41,9 +42,9 @@ process.env.GSD_CODING_AGENT_DIR = agentDir;
 // Prepending gsd's node_modules to NODE_PATH fixes this for all extensions.
 const gsdRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const gsdNodeModules = join(gsdRoot, 'node_modules');
-process.env.NODE_PATH = process.env.NODE_PATH
-    ? `${gsdNodeModules}:${process.env.NODE_PATH}`
-    : gsdNodeModules;
+process.env.NODE_PATH = [gsdNodeModules, process.env.NODE_PATH]
+    .filter(Boolean)
+    .join(delimiter);
 // Force Node to re-evaluate module search paths with the updated NODE_PATH.
 // Must happen synchronously before cli.js imports → extension loading.
 // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -61,34 +62,70 @@ catch {
 // to spawn gsd instead of pi when dispatching workflow tasks
 process.env.GSD_BIN_PATH = process.argv[1];
 // GSD_WORKFLOW_PATH — absolute path to bundled GSD-WORKFLOW.md, used by patched gsd extension
-// when dispatching workflow prompts (dist/loader.js → ../src/resources/GSD-WORKFLOW.md)
-const resourcesDir = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'src', 'resources');
+// when dispatching workflow prompts. Prefers dist/resources/ (stable, set at build time)
+// over src/resources/ (live working tree) — see resource-loader.ts for rationale.
+const loaderPackageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const distRes = join(loaderPackageRoot, 'dist', 'resources');
+const srcRes = join(loaderPackageRoot, 'src', 'resources');
+const resourcesDir = existsSync(distRes) ? distRes : srcRes;
 process.env.GSD_WORKFLOW_PATH = join(resourcesDir, 'GSD-WORKFLOW.md');
-// GSD_BUNDLED_EXTENSION_PATHS — colon-joined list of all bundled extension entry point absolute
-// paths, used by patched subagent to pass --extension <path> to spawned gsd processes.
-// IMPORTANT: paths point to agentDir (~/.gsd/agent/extensions/) NOT src/resources/extensions/.
-// initResources() syncs bundled extensions to agentDir before any extension loading occurs,
-// so these paths are always valid at runtime. Using agentDir paths matches what buildResourceLoader
-// discovers (it scans agentDir), so pi's deduplication works correctly and extensions are not
-// double-loaded in subagent child processes.
-// Note: shared/ is NOT included — it's a library imported by gsd and ask-user-questions, not an entry point.
-process.env.GSD_BUNDLED_EXTENSION_PATHS = [
-    join(agentDir, 'extensions', 'gsd', 'index.ts'),
-    join(agentDir, 'extensions', 'bg-shell', 'index.ts'),
-    join(agentDir, 'extensions', 'browser-tools', 'index.ts'),
-    join(agentDir, 'extensions', 'context7', 'index.ts'),
-    join(agentDir, 'extensions', 'search-the-web', 'index.ts'),
-    join(agentDir, 'extensions', 'slash-commands', 'index.ts'),
-    join(agentDir, 'extensions', 'subagent', 'index.ts'),
-    join(agentDir, 'extensions', 'mac-tools', 'index.ts'),
-    join(agentDir, 'extensions', 'async-jobs', 'index.ts'),
-    join(agentDir, 'extensions', 'ask-user-questions.ts'),
-    join(agentDir, 'extensions', 'get-secrets-from-user.ts'),
-].join(':');
+// GSD_BUNDLED_EXTENSION_PATHS — dynamically discovered bundled extension entry points.
+// Scans the bundled resources directory to find all extensions, then maps paths to
+// agentDir (~/.gsd/agent/extensions/) where initResources() will sync them.
+//
+// Discovery rules (mirroring resource-loader.ts discoverExtensionEntryPaths):
+//   - Top-level .ts/.js files → extension entry point
+//   - Directories with index.ts or index.js → extension entry point
+//   - Directories without either (e.g. shared/, remote-questions/) → skipped
+//
+// Previously this was a hardcoded list that required manual updates whenever
+// extensions were added or removed — causing merge conflicts in forks and
+// falling out of sync with what buildResourceLoader() discovers at runtime.
+const bundledExtDir = join(resourcesDir, 'extensions');
+const agentExtDir = join(agentDir, 'extensions');
+const discoveredExtensionPaths = [];
+if (existsSync(bundledExtDir)) {
+    for (const entry of readdirSync(bundledExtDir, { withFileTypes: true })) {
+        if (entry.isFile() && (entry.name.endsWith('.ts') || entry.name.endsWith('.js'))) {
+            discoveredExtensionPaths.push(join(agentExtDir, entry.name));
+        }
+        else if (entry.isDirectory()) {
+            const srcIndex = existsSync(join(bundledExtDir, entry.name, 'index.ts'))
+                ? 'index.ts'
+                : existsSync(join(bundledExtDir, entry.name, 'index.js'))
+                    ? 'index.js'
+                    : null;
+            if (srcIndex) {
+                discoveredExtensionPaths.push(join(agentExtDir, entry.name, srcIndex));
+            }
+        }
+    }
+}
+process.env.GSD_BUNDLED_EXTENSION_PATHS = serializeBundledExtensionPaths(discoveredExtensionPaths);
 // Respect HTTP_PROXY / HTTPS_PROXY / NO_PROXY env vars for all outbound requests.
 // pi-coding-agent's cli.ts sets this, but GSD bypasses that entry point — so we
 // must set it here before any SDK clients are created.
 import { EnvHttpProxyAgent, setGlobalDispatcher } from 'undici';
 setGlobalDispatcher(new EnvHttpProxyAgent());
+// Ensure workspace packages are linked before importing cli.js (which imports @gsd/*).
+// npm postinstall handles this normally, but npx --ignore-scripts skips postinstall.
+const gsdScopeDir = join(gsdNodeModules, '@gsd');
+const packagesDir = join(gsdRoot, 'packages');
+const wsPackages = ['native', 'pi-agent-core', 'pi-ai', 'pi-coding-agent', 'pi-tui'];
+try {
+    if (!existsSync(gsdScopeDir))
+        mkdirSync(gsdScopeDir, { recursive: true });
+    for (const pkg of wsPackages) {
+        const target = join(gsdScopeDir, pkg);
+        const source = join(packagesDir, pkg);
+        if (existsSync(source) && !existsSync(target)) {
+            try {
+                symlinkSync(source, target, 'junction');
+            }
+            catch { /* non-fatal */ }
+        }
+    }
+}
+catch { /* non-fatal */ }
 // Dynamic import defers ESM evaluation — config.js will see PI_PACKAGE_DIR above
 await import('./cli.js');

package/dist/onboarding.js

@@ -10,7 +10,10 @@
  * All steps are skippable. All errors are recoverable. Never crashes boot.
  */
 import { exec } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { renderLogo } from './logo.js';
+import { agentDir } from './app-paths.js';
 // ─── Constants ────────────────────────────────────────────────────────────────
 const TOOL_KEYS = [
     {
@@ -45,6 +48,7 @@ const LLM_PROVIDER_IDS = [
     'xai',
     'openrouter',
     'mistral',
+    'custom-openai',
 ];
 /** API key prefix validation — loose checks to catch obvious mistakes */
 const API_KEY_PREFIXES = {
@@ -57,6 +61,7 @@ const OTHER_PROVIDERS = [
     { value: 'xai', label: 'xAI (Grok)' },
     { value: 'openrouter', label: 'OpenRouter' },
     { value: 'mistral', label: 'Mistral' },
+    { value: 'custom-openai', label: 'Custom (OpenAI-compatible)' },
 ];
 // ─── Dynamic imports ──────────────────────────────────────────────────────────
 /**
@@ -276,6 +281,9 @@ async function runLlmStep(p, pc, authStorage) {
         });
         if (p.isCancel(provider))
             return false;
+        if (provider === 'custom-openai') {
+            return await runCustomOpenAIFlow(p, pc, authStorage);
+        }
         const label = provider === 'anthropic' ? 'Anthropic'
             : provider === 'openai' ? 'OpenAI'
                 : OTHER_PROVIDERS.find(op => op.value === provider)?.label ?? String(provider);
@@ -365,6 +373,94 @@ async function runApiKeyFlow(p, pc, authStorage, providerId, providerLabel) {
     p.log.success(`API key saved for ${pc.green(providerLabel)}`);
     return true;
 }
+// ─── Custom OpenAI-compatible Flow ────────────────────────────────────────────
+async function runCustomOpenAIFlow(p, pc, authStorage) {
+    // Prompt for base URL
+    const baseUrl = await p.text({
+        message: 'Base URL of your OpenAI-compatible endpoint:',
+        placeholder: 'https://my-proxy.example.com/v1',
+        validate: (val) => {
+            const trimmed = val?.trim();
+            if (!trimmed)
+                return 'Base URL is required';
+            try {
+                new URL(trimmed);
+            }
+            catch {
+                return 'Must be a valid URL (e.g. https://my-proxy.example.com/v1)';
+            }
+        },
+    });
+    if (p.isCancel(baseUrl) || !baseUrl)
+        return false;
+    const trimmedUrl = baseUrl.trim();
+    // Prompt for API key
+    const apiKey = await p.password({
+        message: 'API key for this endpoint:',
+        mask: '●',
+    });
+    if (p.isCancel(apiKey) || !apiKey)
+        return false;
+    const trimmedKey = apiKey.trim();
+    if (!trimmedKey)
+        return false;
+    // Prompt for model ID
+    const modelId = await p.text({
+        message: 'Model ID to use:',
+        placeholder: 'gpt-4o',
+        validate: (val) => {
+            if (!val?.trim())
+                return 'Model ID is required';
+        },
+    });
+    if (p.isCancel(modelId) || !modelId)
+        return false;
+    const trimmedModelId = modelId.trim();
+    // Save API key to auth storage
+    authStorage.set('custom-openai', { type: 'api_key', key: trimmedKey });
+    // Write or merge into models.json
+    const modelsJsonPath = join(agentDir, 'models.json');
+    let config = { providers: {} };
+    if (existsSync(modelsJsonPath)) {
+        try {
+            config = JSON.parse(readFileSync(modelsJsonPath, 'utf-8'));
+            if (!config.providers)
+                config.providers = {};
+        }
+        catch {
+            // If existing file is corrupt, start fresh
+            config = { providers: {} };
+        }
+    }
+    config.providers['custom-openai'] = {
+        baseUrl: trimmedUrl,
+        apiKey: `env:CUSTOM_OPENAI_API_KEY`,
+        api: 'openai-completions',
+        models: [
+            {
+                id: trimmedModelId,
+                name: trimmedModelId,
+                reasoning: false,
+                input: ['text'],
+                contextWindow: 128000,
+                maxTokens: 16384,
+                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+            },
+        ],
+    };
+    // Ensure parent directory exists
+    const dir = dirname(modelsJsonPath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(modelsJsonPath, JSON.stringify(config, null, 2), 'utf-8');
+    // Also set env var so the current session picks up the key via fallback resolver
+    process.env.CUSTOM_OPENAI_API_KEY = trimmedKey;
+    p.log.success(`Custom endpoint saved: ${pc.green(trimmedUrl)}`);
+    p.log.info(`Model: ${pc.cyan(trimmedModelId)}`);
+    p.log.info(`Config written to ${pc.dim(modelsJsonPath)}`);
+    return true;
+}
 // ─── Web Search Provider Step ─────────────────────────────────────────────────
 async function runWebSearchStep(p, pc, authStorage, isAnthropicAuth) {
     // Check which LLM provider was configured
@@ -659,6 +755,7 @@ export function loadStoredEnvKeys(authStorage) {
         ['slack_bot', 'SLACK_BOT_TOKEN'],
         ['discord_bot', 'DISCORD_BOT_TOKEN'],
         ['groq', 'GROQ_API_KEY'],
+        ['custom-openai', 'CUSTOM_OPENAI_API_KEY'],
     ];
     for (const [provider, envVar] of providers) {
         if (!process.env[envVar]) {

package/dist/resource-loader.js

@@ -3,9 +3,18 @@ import { homedir } from 'node:os';
 import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync } from 'node:fs';
 import { dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-// Resolves to the bundled src/resources/ inside the npm package at runtime:
-//   dist/resource-loader.js → .. → package root → src/resources/
-const resourcesDir = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'src', 'resources');
+// Resolve resources directory — prefer dist/resources/ (stable, set at build time)
+// over src/resources/ (live working tree, changes with git branch).
+//
+// Why this matters: with `npm link`, src/resources/ points into the gsd-2 repo's
+// working tree. Switching branches there changes src/resources/ for ALL projects
+// that use gsd — causing stale/broken extensions to be synced to ~/.gsd/agent/.
+// dist/resources/ is populated by the build step (`npm run copy-resources`) and
+// reflects the built state, not the currently checked-out branch.
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const distResources = join(packageRoot, 'dist', 'resources');
+const srcResources = join(packageRoot, 'src', 'resources');
+const resourcesDir = existsSync(distResources) ? distResources : srcResources;
 const bundledExtensionsDir = join(resourcesDir, 'extensions');
 function isExtensionFile(name) {
     return name.endsWith('.ts') || name.endsWith('.js');