@agenthippo-ai/agenthippo 0.1.0

package/out/permissions.mapping.yaml

@@ -0,0 +1,68 @@
+# AgentIDE Permission Mapping
+# Security-auditable mapping from unified permissions to engine SDK options
+#
+# RULE: Most restrictive wins - manifest cannot be bypassed by user settings
+#
+# See PLAN/perm-design.md for full documentation.
+
+version: "1.0"
+
+# Default permissions for agents without explicit permissions
+defaults:
+  fileAccess: workspace-write   # read-only | workspace-write | full
+
+# Claude Agent SDK mapping
+#
+# NOTE: Claude does NOT have a sandboxMode equivalent for fileAccess.
+# File access is controlled via `additionalDirectories` which lists allowed paths.
+# The toClaudeOptions() function handles this by passing workspace folders directly.
+#
+# SECURITY: Claude's `additionalDirectories` is more of a suggestion than a hard
+# sandbox - Claude can still potentially access files outside if it tries.
+# This is an SDK limitation, not something we can fix in the mapping.
+#
+# permissionMode options used by V1:
+#   - 'plan': strict read-only (no tool execution)
+#   - 'acceptEdits': non-interactive auto-accept file edits (workspace-write)
+#   - 'bypassPermissions': non-interactive full access mode
+claude:
+  # fileAccess: read-only
+  readOnly:
+    permissionMode: plan
+    allowDangerouslySkipPermissions: false
+
+  # fileAccess: workspace-write
+  workspaceWrite:
+    permissionMode: acceptEdits
+    allowDangerouslySkipPermissions: false
+
+  # fileAccess: full
+  fullAccess:
+    permissionMode: bypassPermissions
+    allowDangerouslySkipPermissions: true
+
+# Codex SDK mapping
+#
+# NOTE: Codex has explicit sandboxMode for fileAccess control.
+# Approval is non-interactive in V1.
+# - workspace-write: Can only write to workspace folders
+# - danger-full-access: Full filesystem access (requires explicit opt-in)
+#
+# SECURITY: Unlike Claude, Codex's `sandboxMode` is a HARD enforcement at the
+# SDK level. The sandbox cannot be bypassed by the agent.
+codex:
+  approvalPolicy: never
+
+  # fileAccess: read-only
+  readOnly:
+    sandboxMode: read-only
+
+  # fileAccess: workspace-write - Only workspace folders + additionalDirectories
+  # (additionalDirectories always includes all multi-root workspace folders)
+  workspaceWrite:
+    sandboxMode: workspace-write
+
+  # fileAccess: full - Full filesystem access
+  fullAccess:
+    sandboxMode: danger-full-access
+

package/out/registry/index.js

@@ -0,0 +1,332 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------------------------
+ *  Local Registry - JSON file-based registry for pack/skill/MCP discovery.
+ *
+ *  Design:
+ *  - Uses simple JSON files for storage
+ *  - Stores data in ~/.agentide/registry/
+ *  - Provides search and lookup APIs
+ *  - Easy to test with Mocha (no native dependencies)
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalRegistry = void 0;
+exports.getRegistry = getRegistry;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+function createEmptyData() {
+    return { packs: {}, skills: {}, mcp: {} };
+}
+// -----------------------------------------------------------------------------
+// Registry Class
+// -----------------------------------------------------------------------------
+class LocalRegistry {
+    data = null;
+    registryPath;
+    constructor(registryPath, _outputChannel) {
+        this.registryPath = registryPath || path.join(os.homedir(), '.agentide', 'registry.json');
+    }
+    // -------------------------------------------------------------------------
+    // Data Management
+    // -------------------------------------------------------------------------
+    ensureDir() {
+        const dir = path.dirname(this.registryPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+    load() {
+        if (this.data) {
+            return this.data;
+        }
+        if (fs.existsSync(this.registryPath)) {
+            try {
+                const raw = fs.readFileSync(this.registryPath, 'utf-8');
+                this.data = JSON.parse(raw);
+            }
+            catch {
+                this.data = createEmptyData();
+            }
+        }
+        else {
+            this.data = createEmptyData();
+        }
+        return this.data;
+    }
+    save() {
+        if (!this.data) {
+            return;
+        }
+        this.ensureDir();
+        fs.writeFileSync(this.registryPath, JSON.stringify(this.data, null, 2));
+    }
+    // -------------------------------------------------------------------------
+    // Pack Operations
+    // -------------------------------------------------------------------------
+    async registerPack(input) {
+        const data = this.load();
+        data.packs[input.slug] = {
+            slug: input.slug,
+            displayName: input.displayName,
+            description: input.description,
+            githubOwner: input.github?.owner,
+            githubRepo: input.github?.repo,
+            latestVersion: input.latestVersion,
+            tags: input.tags,
+            installs: input.stats.installs,
+            stars: input.stats.stars,
+            updatedAt: Date.now(),
+        };
+        this.save();
+    }
+    async getPack(slug) {
+        const data = this.load();
+        return data.packs[slug] || null;
+    }
+    async listPacks() {
+        const data = this.load();
+        return Object.values(data.packs).sort((a, b) => b.installs - a.installs);
+    }
+    async trackPackInstall(slug) {
+        const data = this.load();
+        const pack = data.packs[slug];
+        if (pack) {
+            pack.installs += 1;
+            pack.updatedAt = Date.now();
+            this.save();
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Skill Operations
+    // -------------------------------------------------------------------------
+    async registerSkill(input) {
+        const data = this.load();
+        const existing = data.skills[input.slug];
+        // Merge installedTo: keep existing agent packs and add new one if provided
+        let installedTo = existing?.installedTo || [];
+        if (input.agentPackId && !installedTo.includes(input.agentPackId)) {
+            installedTo = [...installedTo, input.agentPackId];
+        }
+        data.skills[input.slug] = {
+            slug: input.slug,
+            displayName: input.displayName,
+            description: input.description,
+            githubOwner: input.github?.owner,
+            githubRepo: input.github?.repo,
+            githubPath: input.github?.path,
+            latestVersion: input.latestVersion,
+            tags: input.tags,
+            installs: input.stats.installs,
+            updatedAt: Date.now(),
+            installedTo,
+        };
+        this.save();
+    }
+    async getSkill(slug) {
+        const data = this.load();
+        return data.skills[slug] || null;
+    }
+    async listSkills() {
+        const data = this.load();
+        return Object.values(data.skills).sort((a, b) => b.installs - a.installs);
+    }
+    // -------------------------------------------------------------------------
+    // MCP Operations
+    // -------------------------------------------------------------------------
+    async registerMcp(input) {
+        const data = this.load();
+        const existing = data.mcp[input.slug];
+        // Merge installedTo: keep existing agent packs and add new one if provided
+        let installedTo = existing?.installedTo || [];
+        if (input.agentPackId && !installedTo.includes(input.agentPackId)) {
+            installedTo = [...installedTo, input.agentPackId];
+        }
+        data.mcp[input.slug] = {
+            slug: input.slug,
+            displayName: input.displayName,
+            description: input.description,
+            transport: input.transport,
+            githubOwner: input.github?.owner,
+            githubRepo: input.github?.repo,
+            npmPackage: input.npmPackage,
+            latestVersion: input.latestVersion,
+            tags: input.tags,
+            installs: input.stats.installs,
+            updatedAt: Date.now(),
+            installedTo,
+        };
+        this.save();
+    }
+    async getMcp(slug) {
+        const data = this.load();
+        return data.mcp[slug] || null;
+    }
+    async listMcp() {
+        const data = this.load();
+        return Object.values(data.mcp).sort((a, b) => b.installs - a.installs);
+    }
+    /**
+     * Check if a skill is installed to a specific agent pack.
+     */
+    async isSkillInstalledTo(slug, agentPackId) {
+        const skill = await this.getSkill(slug);
+        return skill?.installedTo?.includes(agentPackId) ?? false;
+    }
+    /**
+     * Check if an MCP is installed to a specific agent pack.
+     */
+    async isMcpInstalledTo(slug, agentPackId) {
+        const mcp = await this.getMcp(slug);
+        return mcp?.installedTo?.includes(agentPackId) ?? false;
+    }
+    /**
+     * Remove an agent pack from a skill's installedTo list.
+     * Used when uninstalling a skill from an agent pack.
+     */
+    async unregisterSkillFromPack(slug, agentPackId) {
+        const data = this.load();
+        const skill = data.skills[slug];
+        if (skill && skill.installedTo) {
+            skill.installedTo = skill.installedTo.filter(id => id !== agentPackId);
+            skill.updatedAt = Date.now();
+            this.save();
+        }
+    }
+    /**
+     * Remove an agent pack from an MCP's installedTo list.
+     * Used when uninstalling an MCP from an agent pack.
+     */
+    async unregisterMcpFromPack(slug, agentPackId) {
+        const data = this.load();
+        const mcp = data.mcp[slug];
+        if (mcp && mcp.installedTo) {
+            mcp.installedTo = mcp.installedTo.filter(id => id !== agentPackId);
+            mcp.updatedAt = Date.now();
+            this.save();
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Search
+    // -------------------------------------------------------------------------
+    async search(query, options) {
+        const types = options?.types || ['pack', 'skill', 'mcp'];
+        const limit = options?.limit || 20;
+        const results = [];
+        const queryLower = query.toLowerCase();
+        const queryTerms = queryLower.split(/\s+/).filter(t => t.length > 0);
+        // Score function - returns 0 if no term matches
+        const score = (item, installs) => {
+            const text = `${item.slug} ${item.displayName} ${item.description || ''} ${item.tags.join(' ')}`.toLowerCase();
+            let termScore = 0;
+            for (const term of queryTerms) {
+                if (text.includes(term)) {
+                    termScore += 10;
+                }
+            }
+            // Only add popularity boost if there's a term match
+            if (termScore === 0) {
+                return 0;
+            }
+            return termScore + installs / 100;
+        };
+        // Search packs
+        if (types.includes('pack')) {
+            const packs = await this.listPacks();
+            for (const pack of packs) {
+                const s = score(pack, pack.installs);
+                if (s > 0) {
+                    results.push({
+                        type: 'pack',
+                        slug: pack.slug,
+                        displayName: pack.displayName,
+                        description: pack.description,
+                        score: s,
+                        data: pack,
+                    });
+                }
+            }
+        }
+        // Search skills
+        if (types.includes('skill')) {
+            const skills = await this.listSkills();
+            for (const skill of skills) {
+                const s = score(skill, skill.installs);
+                if (s > 0) {
+                    results.push({
+                        type: 'skill',
+                        slug: skill.slug,
+                        displayName: skill.displayName,
+                        description: skill.description,
+                        score: s,
+                        data: skill,
+                    });
+                }
+            }
+        }
+        // Search MCP
+        if (types.includes('mcp')) {
+            const mcps = await this.listMcp();
+            for (const mcp of mcps) {
+                const s = score(mcp, mcp.installs);
+                if (s > 0) {
+                    results.push({
+                        type: 'mcp',
+                        slug: mcp.slug,
+                        displayName: mcp.displayName,
+                        description: mcp.description,
+                        score: s,
+                        data: mcp,
+                    });
+                }
+            }
+        }
+        return results.sort((a, b) => b.score - a.score).slice(0, limit);
+    }
+}
+exports.LocalRegistry = LocalRegistry;
+// -----------------------------------------------------------------------------
+// Singleton Instance
+// -----------------------------------------------------------------------------
+let _registry = null;
+function getRegistry(outputChannel) {
+    if (!_registry) {
+        _registry = new LocalRegistry(undefined, outputChannel);
+    }
+    return _registry;
+}

package/out/remote/handleRemoteChat.js

@@ -0,0 +1,122 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLoopbackServeUrl = isLoopbackServeUrl;
+exports.handleRemoteServeChat = handleRemoteServeChat;
+const base_js_1 = require("../engines/base.js");
+const utils_js_1 = require("../utils.js");
+const sessionEvents_js_1 = require("../analytics/sessionEvents.js");
+const serveClient_js_1 = require("./serveClient.js");
+function isLoopbackServeUrl(url) {
+    try {
+        const host = new URL(url).hostname;
+        return host === '127.0.0.1' || host === 'localhost' || host === '::1';
+    }
+    catch {
+        return false;
+    }
+}
+async function handleRemoteServeChat(deps, args) {
+    const { outputChannel, syncService, sessionEventWriter } = deps;
+    const { streamId, message, remoteUrl, remoteManifest, incomingOptions, gatewayEmitter } = args;
+    if (!streamId) {
+        return { error: 'streamId is required - non-streaming mode is no longer supported' };
+    }
+    const abortController = new AbortController();
+    deps.activeRunsByStreamId.set(streamId, {
+        streamId,
+        engine: 'remote',
+        startedAt: Date.now(),
+        abortController,
+    });
+    const ipcEmitter = (0, utils_js_1.createIPCStreamEmitter)(streamId);
+    const chatSessionResource = args.sessionResource;
+    const chatRequestId = args.requestId;
+    const questionEmitter = {
+        ...ipcEmitter,
+        async question(payload) {
+            if (chatSessionResource) {
+                return deps.askQuestionViaWorkbenchTool(chatSessionResource, chatRequestId, payload, abortController.signal);
+            }
+            return deps.askQuestionFromChatUI(streamId, payload);
+        },
+    };
+    const emitter = gatewayEmitter ? {
+        ...questionEmitter,
+        async thinking(delta) {
+            await ipcEmitter.thinking(delta);
+            await gatewayEmitter.thinking(`<thinking>${delta}</thinking>`);
+        },
+        async text(delta) {
+            await ipcEmitter.text(delta);
+            await gatewayEmitter.text(delta);
+        },
+        async toolStart(toolName, input, toolCallId, metadata) {
+            await ipcEmitter.toolStart(toolName, input, toolCallId, metadata);
+            await gatewayEmitter.toolStart(toolName, input, toolCallId, metadata);
+        },
+        async toolEnd(toolName, toolCallId, result, isError, metadata) {
+            await ipcEmitter.toolEnd(toolName, toolCallId, result, isError, metadata);
+            await gatewayEmitter.toolEnd(toolName, toolCallId, result, isError, metadata);
+        },
+        async progress(msg) {
+            await ipcEmitter.progress(msg);
+            await gatewayEmitter.progress(msg);
+        },
+        async question(payload) {
+            return questionEmitter.question(payload);
+        },
+        async error(msg) {
+            await ipcEmitter.error(msg);
+            await gatewayEmitter.error(msg);
+        },
+        async done() {
+            await ipcEmitter.done();
+            await gatewayEmitter.done();
+        },
+    } : questionEmitter;
+    const requestId = (0, base_js_1.generateRequestId)();
+    let auth = deps.getServeAuth ? await deps.getServeAuth() : undefined;
+    if (!isLoopbackServeUrl(remoteUrl) && !auth?.accessToken && deps.ensureSignedIn) {
+        auth = await deps.ensureSignedIn();
+    }
+    if (!isLoopbackServeUrl(remoteUrl) && !auth?.accessToken) {
+        const authError = 'Sign in to AgentHippo was cancelled or timed out. Use Command Palette → "Sign In to AgentHippo" to try again.';
+        await emitter.error(authError);
+        await emitter.done();
+        return { error: authError };
+    }
+    const remoteSessionId = incomingOptions.contextSessionId?.trim() ||
+        incomingOptions.sessionId?.trim() ||
+        `ide-remote-${streamId}`;
+    const observableEmitter = (0, sessionEvents_js_1.wrapEmitterWithObservability)(emitter, sessionEventWriter, remoteSessionId, requestId);
+    deps.log(outputChannel, `[AgentIDE] Remote serve chat: url=${remoteUrl}, session=${remoteSessionId}, agent=${remoteManifest?.metadata?.name ?? 'unknown'}`);
+    try {
+        syncService.incrementActiveAgentTurns();
+        await observableEmitter.emitTurnStart();
+        await (0, serveClient_js_1.streamRemoteServeChat)({
+            baseUrl: remoteUrl,
+            message,
+            sessionId: remoteSessionId,
+            signal: abortController.signal,
+            auth,
+        }, observableEmitter);
+        await observableEmitter.emitTurnEnd(true);
+        return { streaming: true };
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        deps.log(outputChannel, `[AgentIDE] Remote serve error: ${errorMsg}`);
+        await observableEmitter.error(errorMsg);
+        await observableEmitter.done();
+        await observableEmitter.emitTurnEnd(false);
+        return { error: errorMsg };
+    }
+    finally {
+        deps.rejectPendingQuestionsForStream(streamId, 'Run finished');
+        deps.activeRunsByStreamId.delete(streamId);
+        syncService.decrementActiveAgentTurns();
+    }
+}

package/out/remote/remotePackStatusBar.js

@@ -0,0 +1,103 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemotePackStatusBar = void 0;
+exports.formatRemotePackHost = formatRemotePackHost;
+exports.formatRemotePackStatusLabel = formatRemotePackStatusLabel;
+const vscode = __importStar(require("vscode"));
+const serveClient_js_1 = require("./serveClient.js");
+function formatRemotePackHost(url) {
+    try {
+        return new URL(url).host;
+    }
+    catch {
+        return url;
+    }
+}
+function formatRemotePackStatusLabel(packId, remoteUrl) {
+    return `Remote · ${packId} @ ${formatRemotePackHost(remoteUrl)}`;
+}
+class RemotePackStatusBar {
+    syncService;
+    getWorkspaceRoot;
+    outputChannel;
+    item;
+    isRemoteActive = false;
+    constructor(syncService, getWorkspaceRoot, outputChannel) {
+        this.syncService = syncService;
+        this.getWorkspaceRoot = getWorkspaceRoot;
+        this.outputChannel = outputChannel;
+        this.item = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 98);
+        this.item.name = 'AgentHippo Remote Agent';
+    }
+    async refresh(options) {
+        const wasRemote = this.isRemoteActive;
+        let manifest;
+        try {
+            manifest = await this.syncService.getActiveAgentManifest(this.getWorkspaceRoot(), this.outputChannel);
+        }
+        catch {
+            this.hide();
+            return;
+        }
+        const remoteUrl = (0, serveClient_js_1.getRemoteServeUrl)(manifest);
+        const packId = manifest?.metadata?.name;
+        if (remoteUrl && packId) {
+            this.item.text = `$(globe) ${formatRemotePackStatusLabel(packId, remoteUrl)}`;
+            this.item.tooltip = [
+                `Chat runs on remote serve at ${remoteUrl}.`,
+                'Engine and model are fixed on the server; the mode/model picker has no effect.',
+            ].join('\n');
+            this.item.show();
+            this.isRemoteActive = true;
+            if (options?.notifyOnActivate && !wasRemote) {
+                void vscode.window.showInformationMessage(`Remote agent active: ${packId} @ ${formatRemotePackHost(remoteUrl)}. Engine/model picker has no effect.`);
+            }
+            return;
+        }
+        this.hide();
+    }
+    hide() {
+        this.item.hide();
+        this.isRemoteActive = false;
+    }
+    dispose() {
+        this.item.dispose();
+    }
+}
+exports.RemotePackStatusBar = RemotePackStatusBar;