@aion0/forge 0.8.1 → 0.8.3

package/components/SettingsModal.tsx

@@ -1834,3 +1834,4 @@ function DocsAgentSelect({ settings, setSettings }: { settings: any; setSettings
     </div>
   );
 }
+

package/components/SkillsPanel.tsx

@@ -1,6 +1,6 @@
 'use client';
 
-import { useState, useEffect, useCallback, lazy, Suspense } from 'react';
+import { useState, useEffect, useCallback, useRef, lazy, Suspense } from 'react';
 import { useSidebarResize } from '@/hooks/useSidebarResize';
 
 const PluginsPanel = lazy(() => import('./PluginsPanel'));
@@ -25,6 +25,7 @@ interface Skill {
   hasUpdate: boolean;
   installedProjects: string[];
   deletedRemotely: boolean;
+  source?: 'registry' | 'local';
 }
 
 interface ProjectInfo {
@@ -238,6 +239,26 @@ export default function SkillsPanel({ projectFilter }: { projectFilter?: string
   };
 
   const [syncProgress, setSyncProgress] = useState('');
+  const [uploading, setUploading] = useState(false);
+  const skillUploadRef = useRef<HTMLInputElement | null>(null);
+
+  async function uploadSkillFile(file: File) {
+    setUploading(true);
+    try {
+      const fd = new FormData();
+      fd.append('file', file);
+      const r = await fetch('/api/skills/install-local', { method: 'POST', body: fd });
+      const j = await r.json();
+      if (!r.ok || j.ok === false) {
+        alert(`Upload failed: ${j.error || `HTTP ${r.status}`}`);
+        return;
+      }
+      await fetchSkills();
+    } catch (e) {
+      alert(`Upload failed: ${e instanceof Error ? e.message : String(e)}`);
+    } finally { setUploading(false); }
+  }
+
   const sync = async () => {
     setSyncing(true);
     setSyncProgress('');
@@ -390,6 +411,26 @@ export default function SkillsPanel({ projectFilter }: { projectFilter?: string
           </div>
         </div>
         <span className="text-[8px] px-1.5 py-0.5 rounded bg-blue-500/15 text-blue-400">Claude Code</span>
+        <input
+          ref={skillUploadRef}
+          type="file"
+          accept=".md,.zip"
+          className="hidden"
+          onChange={(e) => {
+            const f = e.target.files?.[0];
+            e.target.value = '';
+            if (f) void uploadSkillFile(f);
+          }}
+        />
+        <button
+          type="button"
+          onClick={() => skillUploadRef.current?.click()}
+          disabled={uploading}
+          title="Upload a local skill — SKILL.md or a .zip bundle. Falls outside the forge-skills registry."
+          className="text-[9px] text-[var(--text-secondary)] hover:text-[var(--text-primary)] disabled:opacity-50"
+        >
+          {uploading ? 'Uploading…' : '+ Upload'}
+        </button>
         <button
           onClick={sync}
           disabled={syncing}

package/lib/agents/claude-adapter.ts

@@ -62,6 +62,10 @@ export function createClaudeAdapter(config: AgentConfig): AgentAdapter {
         args.push('--resume', opts.conversationId);
       }
 
+      if (opts.appendSystemPrompt && opts.appendSystemPrompt.trim()) {
+        args.push('--append-system-prompt', opts.appendSystemPrompt);
+      }
+
       if (opts.extraFlags) {
         args.push(...opts.extraFlags);
       }

package/lib/agents/types.ts

@@ -42,6 +42,12 @@ export interface AgentSpawnOptions {
   skipPermissions?: boolean;
   outputFormat?: 'stream-json' | 'json' | 'text';
   extraFlags?: string[];
+  /**
+   * Extra text appended to the agent's system prompt for this run.
+   * Maps to `--append-system-prompt` on Claude Code. Adapters that
+   * don't support the concept ignore it.
+   */
+  appendSystemPrompt?: string;
 }
 
 export interface AgentSpawnResult {

package/lib/chat/agent-loop.ts

@@ -27,11 +27,10 @@ import { renderMemoryContext } from './temper';
 import { getMemoryStore } from './memory-store';
 import { buildMemoryTools } from './memory-tools';
 import {
-  listPlugins,
-  getPlugin,
-  getInstalledPlugin,
-  getConnectorsForPlugin,
-} from '../plugins/registry';
+  listInstalledConnectors,
+  getConnector,
+  getConnectorEntries,
+} from '../connectors/registry';
 import type {
   ContentBlock,
   Message,
@@ -224,18 +223,10 @@ function detectMentionedConnectors(
 
 function buildConnectorTools(): LlmTool[] {
   const out: LlmTool[] = [];
-  const sources = listPlugins().filter(s => s.category === 'connector');
-  for (const s of sources) {
-    const def = getPlugin(s.id);
-    if (!def) continue;
-    // We deliberately DO NOT require getInstalledPlugin(s.id) here — the LLM
-    // should always see all connector tools the user has defined. Install
-    // status only matters at dispatch time: browser tools that lack a
-    // configured base_url will surface a clear error inside the tool_result
-    // (better than vanishing from the tool list and having the LLM make up
-    // an excuse like "I can't see your Teams"). http/shell tools don't need
-    // install at all.
-    for (const entry of getConnectorsForPlugin(def)) {
+  for (const inst of listInstalledConnectors()) {
+    if (!inst.enabled) continue;
+    const def = inst.definition;
+    for (const entry of getConnectorEntries(def)) {
       for (const [toolName, tool] of Object.entries(entry.tools || {})) {
         // Executable if it has a script (browser protocol) OR a non-browser
         // protocol that runs server-side (http / shell).
@@ -249,8 +240,8 @@ function buildConnectorTools(): LlmTool[] {
           if ((pdef as any)?.required) required.push(pname);
         }
         out.push({
-          name: `${s.id}.${toolName}`,
-          description: (tool.description || `${s.name} · ${toolName}`).trim(),
+          name: `${def.id}.${toolName}`,
+          description: (tool.description || `${def.name} · ${toolName}`).trim(),
           input_schema: {
             type: 'object',
             properties,
@@ -361,9 +352,9 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
   // restrict the tool list so the LLM can't wander to unrelated connectors.
   // Strong (slash-prefix) signals also emit a directive in the system prompt
   // so the model treats it as a command, not a hint.
-  const allPluginIds = [...new Set(connectorTools.map((t) => t.name.split('.')[0]!))];
-  const pluginCatalog = allPluginIds.map((id) => {
-    const def = getPlugin(id);
+  const allConnectorIds = [...new Set(connectorTools.map((t) => t.name.split('.')[0]!))];
+  const pluginCatalog = allConnectorIds.map((id) => {
+    const def = getConnector(id);
     return { id, name: def?.name };
   });
   const mentioned = detectMentionedConnectors(args.userText, pluginCatalog);

package/lib/chat/protocols/http.ts

@@ -15,7 +15,7 @@
  * is_error so the LLM can react.
  */
 
-import type { HttpRequestSpec, ConnectorTool } from '../../plugins/types';
+import type { HttpRequestSpec, ConnectorTool } from '../../connectors/types';
 import { expandAllTokens } from '../../plugins/templates';
 
 export interface HttpProtocolArgs {

package/lib/chat/protocols/shell.ts

@@ -15,7 +15,7 @@
  * automatic command allow-list in v1.
  */
 
-import type { ConnectorTool } from '../../plugins/types';
+import type { ConnectorTool } from '../../connectors/types';
 import { expandAllTokens } from '../../plugins/templates';
 import { spawn } from 'node:child_process';
 

package/lib/chat/tool-dispatcher.ts

@@ -13,12 +13,12 @@ import { bridgeRpc } from './bridge-client';
 import { runHttp } from './protocols/http';
 import { runShell } from './protocols/shell';
 import {
-  getPlugin,
-  getInstalledPlugin,
-  getConnectorsForPlugin,
-} from '../plugins/registry';
+  getConnector,
+  getInstalledConnector,
+  getConnectorEntries,
+} from '../connectors/registry';
 import { expandSettingsTokens } from '../plugins/templates';
-import type { Connector, ConnectorTool } from '../plugins/types';
+import type { ConnectorEntry, ConnectorTool } from '../connectors/types';
 
 export interface ToolCall {
   id: string;
@@ -55,26 +55,26 @@ export const BUILTIN_TOOL_DEFS: BuiltinToolDef[] = [
 
 // ─── Connector dispatch ──────────────────────────────────
 
-/** Look up a connector tool by `<plugin_id>.<tool_name>` form. */
+/** Look up a connector tool by `<connector_id>.<tool_name>` form. */
 function findConnectorTool(qualified: string): {
-  pluginId: string;
+  connectorId: string;
   toolName: string;
-  entry: Connector;
+  entry: ConnectorEntry;
   tool: ConnectorTool;
   settings: Record<string, any>;
 } | null {
   const dot = qualified.indexOf('.');
   if (dot < 1) return null;
-  const pluginId = qualified.slice(0, dot);
+  const connectorId = qualified.slice(0, dot);
   const toolName = qualified.slice(dot + 1);
-  const def = getPlugin(pluginId);
-  if (!def || def.category !== 'connector') return null;
-  const entries = getConnectorsForPlugin(def);
+  const def = getConnector(connectorId);
+  if (!def) return null;
+  const entries = getConnectorEntries(def);
   for (const entry of entries) {
     const tool = entry.tools?.[toolName];
     if (tool) {
-      const inst = getInstalledPlugin(pluginId);
-      return { pluginId, toolName, entry, tool, settings: inst?.config || {} };
+      const inst = getInstalledConnector(connectorId);
+      return { connectorId, toolName, entry, tool, settings: (inst?.config as Record<string, any>) || {} };
     }
   }
   return null;
@@ -86,8 +86,8 @@ function findConnectorTool(qualified: string): {
  * the extension's runner finishes those at execution time.
  */
 function buildConnectorPayload(
-  def: { id: string; name: string; mode?: string; runner?: 'main' | 'isolated'; host_match?: string; login_redirect?: string },
-  entry: Connector,
+  def: { id: string; name: string; runner?: 'main' | 'isolated'; host_match?: string; login_redirect?: string },
+  entry: ConnectorEntry,
   settings: Record<string, any>,
 ) {
   const expand = (s: string | undefined) => (s ? expandSettingsTokens(s, settings) : s);
@@ -117,9 +117,9 @@ function buildConnectorPayload(
   };
 
   return {
-    plugin_id: def.id,
+    plugin_id: def.id,             // legacy wire-name; extension reads this
     name: def.name,
-    mode: def.mode || 'browser-side',
+    mode: 'browser-side',
     installed: true,
     host_match: hostMatch,
     login_redirect: loginRedirect,
@@ -157,7 +157,7 @@ export async function dispatchTool(
     return { content: `unknown tool: ${call.name}`, is_error: true };
   }
 
-  const def = getPlugin(located.pluginId)!;
+  const def = getConnector(located.connectorId)!;
   const protocol = located.tool.protocol || 'browser';
   const argInput = (call.input ?? {}) as Record<string, any>;
 
@@ -173,7 +173,7 @@ export async function dispatchTool(
         // the runner logic (tab acquire, navigate, executeScript).
         const connector = buildConnectorPayload(def, located.entry, located.settings);
         const result = (await bridgeRpc('connector.run', {
-          pluginId: located.pluginId,
+          pluginId: located.connectorId,       // wire-name kept for extension
           toolName: located.toolName,
           input: argInput,
           connector,

package/lib/connectors/migration.ts

@@ -0,0 +1,110 @@
+/**
+ * One-shot migration: lift connector rows out of plugin-configs.json
+ * into connector-configs.json.
+ *
+ * Pre-v0.9 Forge stored connector configs under plugin-configs.json
+ * with `category: connector` on the plugin def. From v0.9 connectors
+ * are an independent subsystem; configs live in connector-configs.json
+ * and manifests come from the remote forge-connectors registry (no
+ * built-in fallback).
+ *
+ * Migration moves the encrypted config blob (PAT, base_url, etc.)
+ * keyed by KNOWN_CONNECTOR_IDS — the set of connector ids that used
+ * to be built in. Manifests are NOT written here; they arrive on the
+ * next syncRegistry() call. If the user is offline at upgrade time,
+ * the marketplace will be empty until they reconnect — config rows
+ * are preserved so re-install restores everything.
+ *
+ * Idempotent: once a connector id has been moved, its row is gone
+ * from plugin-configs.json and subsequent calls are no-ops.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getDataDir } from '../dirs';
+
+/**
+ * IDs that used to ship as built-in connectors in lib/builtin-plugins/.
+ * Add to this list when promoting a new built-in connector into the
+ * marketplace, but only for the upgrade window — once your user base
+ * has restarted with the new code, the row is gone and the entry
+ * becomes inert.
+ */
+const KNOWN_CONNECTOR_IDS = ['mantis', 'gitlab', 'teams', 'pmdb', 'github-api'];
+
+function pluginConfigsPath(): string {
+  return join(getDataDir(), 'plugin-configs.json');
+}
+
+function connectorConfigsPath(): string {
+  return join(getDataDir(), 'connector-configs.json');
+}
+
+function ensureDir(p: string): void {
+  if (!existsSync(p)) mkdirSync(p, { recursive: true, mode: 0o700 });
+}
+
+interface ConnectorConfigRow {
+  config: Record<string, unknown>;
+  /**
+   * Version recorded at migration time. We don't know what version
+   * the user was running before — write '0.0.0' so the next sync,
+   * which sees the registry version > 0.0.0, flags an update and
+   * pulls the manifest. The marketplace UI shows it as "Update
+   * available" briefly until that completes.
+   */
+  installed_version: string;
+  enabled?: boolean;
+}
+
+export function migrateConnectorConfigs(): { migrated: number; skipped: number } {
+  const oldPath = pluginConfigsPath();
+  if (!existsSync(oldPath)) return { migrated: 0, skipped: 0 };
+
+  let oldStore: Record<string, any>;
+  try { oldStore = JSON.parse(readFileSync(oldPath, 'utf-8')); }
+  catch { return { migrated: 0, skipped: 0 }; }
+
+  const newPath = connectorConfigsPath();
+  let newStore: Record<string, ConnectorConfigRow> = {};
+  if (existsSync(newPath)) {
+    try { newStore = JSON.parse(readFileSync(newPath, 'utf-8')); }
+    catch {}
+  }
+
+  let migrated = 0;
+  let skipped = 0;
+  const toRemoveFromOld: string[] = [];
+
+  for (const id of KNOWN_CONNECTOR_IDS) {
+    const oldRow = oldStore[id];
+    if (!oldRow) {
+      skipped += 1;
+      continue;
+    }
+    if (!newStore[id]) {
+      newStore[id] = {
+        config: oldRow.config || {},
+        installed_version: '0.0.0',
+        enabled: oldRow.enabled !== false,
+      };
+      migrated += 1;
+    }
+    toRemoveFromOld.push(id);
+  }
+
+  if (toRemoveFromOld.length > 0) {
+    ensureDir(getDataDir());
+    writeFileSync(newPath, JSON.stringify(newStore, null, 2), { mode: 0o600 });
+
+    for (const id of toRemoveFromOld) delete oldStore[id];
+    writeFileSync(oldPath, JSON.stringify(oldStore, null, 2), { mode: 0o600 });
+
+    console.log(
+      `[connectors] migration: moved ${migrated} row(s) from plugin-configs.json. ` +
+        'Manifests will arrive on the next registry sync.',
+    );
+  }
+
+  return { migrated, skipped };
+}