ohmyvibe 0.1.4 → 0.1.5

package/dist/daemon/httpServer.js

@@ -62,13 +62,33 @@ export function startHttpServer(sessionManager, port) {
         }
     });
     app.get("/api/sessions/:sessionId", (req, res) => {
-        const session = sessionManager.get(req.params.sessionId);
+        const limit = typeof req.query.limit === "string" && Number.isFinite(Number(req.query.limit))
+            ? Number(req.query.limit)
+            : undefined;
+        const session = sessionManager.get(req.params.sessionId, { limit });
         if (!session) {
             res.status(404).json({ error: "Session not found" });
             return;
         }
         res.json(session);
     });
+    app.get("/api/sessions/:sessionId/transcript", (req, res) => {
+        try {
+            const beforeEntryId = typeof req.query.beforeEntryId === "string" ? req.query.beforeEntryId : undefined;
+            const limit = typeof req.query.limit === "string" && Number.isFinite(Number(req.query.limit))
+                ? Number(req.query.limit)
+                : undefined;
+            const page = sessionManager.getTranscriptPage(req.params.sessionId, { beforeEntryId, limit });
+            if (!page) {
+                res.status(404).json({ error: "Session not found" });
+                return;
+            }
+            res.json(page);
+        }
+        catch (error) {
+            res.status(400).json({ error: error instanceof Error ? error.message : String(error) });
+        }
+    });
     app.post("/api/sessions/:sessionId/messages", async (req, res) => {
         try {
             const body = req.body;

package/dist/daemon/index.js

@@ -1,12 +1,14 @@
 import "dotenv/config";
 import { ManagementBridge } from "./managementBridge.js";
+import { ProjectManager } from "./projectManager.js";
 import { SessionManager } from "./sessionManager.js";
 const sessionManager = new SessionManager();
+const projectManager = new ProjectManager(sessionManager);
 const managementServerUrl = process.env.MANAGEMENT_SERVER_URL;
 if (!managementServerUrl) {
     throw new Error("MANAGEMENT_SERVER_URL is required");
 }
-const bridge = new ManagementBridge(sessionManager, {
+const bridge = new ManagementBridge(projectManager, {
     serverUrl: managementServerUrl,
     daemonId: process.env.DAEMON_ID,
     daemonName: process.env.DAEMON_NAME,

package/dist/daemon/jsonRpc.js

@@ -6,6 +6,7 @@ export class JsonRpcProcess extends EventEmitter {
     nextId = 1;
     stdoutBuffer = "";
     stderrBuffer = "";
+    finished = false;
     constructor(command, args, cwd) {
         super();
         this.child = spawn(command, args, {
@@ -17,15 +18,17 @@ export class JsonRpcProcess extends EventEmitter {
         this.child.stderr.setEncoding("utf8");
         this.child.stdout.on("data", (chunk) => this.onStdout(chunk));
         this.child.stderr.on("data", (chunk) => this.onStderr(chunk));
+        this.child.stdin.on("error", (error) => this.handleFailure(error));
+        this.child.stdout.on("error", (error) => this.handleFailure(error));
+        this.child.stderr.on("error", (error) => this.handleFailure(error));
         this.child.on("error", (error) => {
-            for (const pending of this.pending.values()) {
-                pending.reject(error);
-            }
-            this.pending.clear();
-            this.emit("stderr", error.message);
-            this.emit("exit", { code: null, signal: null });
+            this.handleFailure(error, { code: null, signal: null });
         });
         this.child.on("exit", (code, signal) => {
+            if (this.finished) {
+                return;
+            }
+            this.finished = true;
             this.flushStderr();
             const error = new Error(`JSON-RPC process exited (code=${code}, signal=${signal})`);
             for (const pending of this.pending.values()) {
@@ -133,4 +136,17 @@ export class JsonRpcProcess extends EventEmitter {
             this.emit("stderr", remaining);
         }
     }
+    handleFailure(error, exit = { code: null, signal: null }) {
+        if (this.finished) {
+            return;
+        }
+        this.finished = true;
+        for (const pending of this.pending.values()) {
+            pending.reject(error);
+        }
+        this.pending.clear();
+        this.flushStderr();
+        this.emit("stderr", error.message);
+        this.emit("exit", exit);
+    }
 }

package/dist/daemon/managementBridge.js

@@ -6,20 +6,20 @@ export class ManagementBridge {
     serverUrl;
     daemonId;
     daemonName;
-    sessionManager;
+    projectManager;
     socket;
     reconnectTimer;
     eventFlushTimer;
     pendingEvents = [];
-    constructor(sessionManager, options) {
-        this.sessionManager = sessionManager;
+    constructor(projectManager, options) {
+        this.projectManager = projectManager;
         this.serverUrl = options.serverUrl;
         this.daemonId = options.daemonId ?? randomUUID();
         this.daemonName = options.daemonName ?? os.hostname();
     }
     start() {
         this.connect();
-        this.sessionManager.on("event", (event) => {
+        this.projectManager.on("event", (event) => {
             this.enqueueEvent(event);
         });
     }
@@ -94,9 +94,11 @@ export class ManagementBridge {
                 connectedAt: new Date().toISOString(),
                 lastSeenAt: new Date().toISOString(),
                 online: true,
-                sessionCount: this.sessionManager.list().length,
+                sessionCount: this.projectManager.listSessionsCached().length,
             },
-            sessions: this.sessionManager.list(),
+            sessions: this.projectManager.listSessionsCached(),
+            projects: this.projectManager.listProjects(),
+            agents: this.projectManager.listAgents(),
         });
     }
     enqueueEvent(event) {
@@ -123,23 +125,38 @@ export class ManagementBridge {
     async handleRequest(method, params) {
         switch (method) {
             case "getConfig":
-                return this.sessionManager.getConfig();
+                return this.projectManager.getConfig();
             case "listSessions":
-                return this.sessionManager.list();
+                return this.projectManager.listSessions();
             case "getSession":
-                return this.sessionManager.get(String(params.sessionId));
+                return this.projectManager.getSession(String(params.sessionId), {
+                    limit: typeof params.limit === "number" ? params.limit : undefined,
+                });
+            case "getSessionTranscript":
+                return this.projectManager.getTranscriptPage(String(params.sessionId), {
+                    beforeEntryId: typeof params.beforeEntryId === "string" ? params.beforeEntryId : undefined,
+                    limit: typeof params.limit === "number" ? params.limit : undefined,
+                });
             case "listHistory":
-                return this.sessionManager.listHistory();
+                return this.projectManager.listHistory();
             case "browseDirectories":
-                return this.sessionManager.browseDirectories(typeof params.path === "string" ? params.path : undefined);
+                return this.projectManager.browseDirectories(typeof params.path === "string" ? params.path : undefined);
             case "browseSessionFiles":
-                return this.sessionManager.browseSessionFiles(String(params.sessionId), typeof params.path === "string" ? params.path : undefined);
+                return this.projectManager.browseSessionFiles(String(params.sessionId), typeof params.path === "string" ? params.path : undefined);
             case "readSessionFile":
-                return this.sessionManager.readSessionFile(String(params.sessionId), String(params.path));
+                return this.projectManager.readSessionFile(String(params.sessionId), String(params.path));
             case "writeSessionFile":
-                return this.sessionManager.writeSessionFile(String(params.sessionId), String(params.path), String(params.content ?? ""));
+                return this.projectManager.writeSessionFile(String(params.sessionId), String(params.path), String(params.content ?? ""));
             case "createSession":
-                return this.sessionManager.create({
+                return this.projectManager.createSession({
+                    cwd: String(params.cwd ?? process.cwd()),
+                    model: typeof params.model === "string" ? params.model : undefined,
+                    reasoningEffort: typeof params.reasoningEffort === "string" ? params.reasoningEffort : undefined,
+                    sandbox: typeof params.sandbox === "string" ? params.sandbox : undefined,
+                    approvalPolicy: typeof params.approvalPolicy === "string" ? params.approvalPolicy : undefined,
+                });
+            case "createProjectSession":
+                return this.projectManager.createProjectSession(String(params.projectId), {
                     cwd: String(params.cwd ?? process.cwd()),
                     model: typeof params.model === "string" ? params.model : undefined,
                     reasoningEffort: typeof params.reasoningEffort === "string" ? params.reasoningEffort : undefined,
@@ -147,7 +164,7 @@ export class ManagementBridge {
                     approvalPolicy: typeof params.approvalPolicy === "string" ? params.approvalPolicy : undefined,
                 });
             case "restoreSession":
-                return this.sessionManager.restore({
+                return this.projectManager.restoreSession({
                     threadId: String(params.threadId),
                     cwd: typeof params.cwd === "string" ? params.cwd : undefined,
                     model: typeof params.model === "string" ? params.model : undefined,
@@ -156,27 +173,65 @@ export class ManagementBridge {
                     approvalPolicy: typeof params.approvalPolicy === "string" ? params.approvalPolicy : undefined,
                 });
             case "sendMessage":
-                await this.sessionManager.sendMessage(String(params.sessionId), String(params.text ?? ""));
+                await this.projectManager.sendMessage(String(params.sessionId), String(params.text ?? ""));
                 return { ok: true };
             case "updateSessionConfig":
-                return this.sessionManager.updateConfig(String(params.sessionId), {
+                return this.projectManager.updateSessionConfig(String(params.sessionId), {
                     model: typeof params.model === "string" ? params.model : undefined,
                     reasoningEffort: typeof params.reasoningEffort === "string" ? params.reasoningEffort : undefined,
                     sandbox: typeof params.sandbox === "string" ? params.sandbox : undefined,
                     approvalPolicy: typeof params.approvalPolicy === "string" ? params.approvalPolicy : undefined,
                 });
             case "renameSession":
-                return this.sessionManager.rename(String(params.sessionId), {
+                return this.projectManager.renameSession(String(params.sessionId), {
                     title: String(params.title ?? ""),
                 });
             case "interruptSession":
-                await this.sessionManager.interrupt(String(params.sessionId));
+                await this.projectManager.interruptSession(String(params.sessionId));
                 return { ok: true };
             case "respondApproval":
-                return this.sessionManager.respondApproval(String(params.sessionId), String(params.approvalRequestId), params.decision === "deny" ? "deny" : "approve");
+                return this.projectManager.respondApproval(String(params.sessionId), String(params.approvalRequestId), params.decision === "deny" ? "deny" : "approve");
             case "closeSession":
-                await this.sessionManager.close(String(params.sessionId));
+                await this.projectManager.closeSession(String(params.sessionId));
                 return { ok: true };
+            case "listProjects":
+                return this.projectManager.listProjects();
+            case "getProject":
+                return this.projectManager.getProject(String(params.projectId));
+            case "createProject":
+                return this.projectManager.createProject({
+                    name: String(params.name ?? ""),
+                    rootDir: String(params.rootDir ?? process.cwd()),
+                    goal: typeof params.goal === "string" ? params.goal : undefined,
+                    runPolicy: params.runPolicy,
+                });
+            case "updateProject":
+                return this.projectManager.updateProject(String(params.projectId), {
+                    name: typeof params.name === "string" ? params.name : undefined,
+                    goal: typeof params.goal === "string" ? params.goal : undefined,
+                    status: typeof params.status === "string" ? params.status : undefined,
+                    runPolicy: params.runPolicy,
+                });
+            case "listAgents":
+                return this.projectManager.listAgents(typeof params.projectId === "string" ? params.projectId : undefined);
+            case "getAgent":
+                return this.projectManager.getAgent(String(params.agentId));
+            case "sendAgentMessage":
+                return this.projectManager.sendAgentMessage(String(params.projectId), String(params.agentId), String(params.text ?? ""));
+            case "clearAgentLogs":
+                return this.projectManager.clearAgentLogs(String(params.projectId), String(params.agentId));
+            case "runProject":
+                return this.projectManager.runProject(String(params.projectId));
+            case "pauseProject":
+                return this.projectManager.pauseProject(String(params.projectId));
+            case "getSettings":
+                return this.projectManager.getSettings();
+            case "updateProviderConfig":
+                return this.projectManager.updateProviderConfig(params);
+            case "updateNotificationConfig":
+                return this.projectManager.updateNotificationConfig(params);
+            case "listNotifications":
+                return this.projectManager.listNotifications(typeof params.projectId === "string" ? params.projectId : undefined);
             default:
                 throw new Error(`Unsupported bridge method: ${method}`);
         }

package/dist/daemon/openAiAgentClient.js

@@ -0,0 +1,378 @@
+export class OpenAiAgentClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async decide(agent, messages) {
+        if (this.config.apiFormat === "chat_completions") {
+            return this.decideWithChatCompletions(agent, messages);
+        }
+        return this.decideWithResponses(agent, messages);
+    }
+    async decideWithResponses(agent, messages) {
+        const payload = await this.createResponsesRequest({
+            model: this.config.model || agent.model,
+            temperature: this.config.temperature ?? 0.2,
+            max_output_tokens: this.config.maxOutputTokens ?? 4000,
+            input: messages.map((message) => ({
+                role: message.role,
+                content: message.content,
+            })),
+            tool_choice: "required",
+            tools: buildResponsesDecisionTools(),
+        });
+        const decision = parseDecisionFromResponsesOutput(payload);
+        if (decision) {
+            return decision;
+        }
+        throw new Error("OpenAI responses output did not include a tool call");
+    }
+    async decideWithChatCompletions(agent, messages) {
+        const toolPayload = await this.createChatCompletion({
+            model: this.config.model || agent.model,
+            temperature: this.config.temperature ?? 0.2,
+            max_tokens: this.config.maxOutputTokens ?? 4000,
+            messages,
+            tool_choice: "required",
+            tools: buildChatDecisionTools(),
+        });
+        const toolDecision = parseDecisionFromToolResponse(toolPayload);
+        if (toolDecision) {
+            return toolDecision;
+        }
+        const legacyPayload = await this.createChatCompletion({
+            model: this.config.model || agent.model,
+            temperature: this.config.temperature ?? 0.2,
+            max_tokens: this.config.maxOutputTokens ?? 4000,
+            messages,
+            function_call: { name: "agent_decide" },
+            functions: [buildLegacyDecisionFunction()],
+        });
+        const legacyDecision = parseDecisionFromLegacyFunctionResponse(legacyPayload);
+        if (legacyDecision) {
+            return legacyDecision;
+        }
+        throw new Error("OpenAI chat completions output did not include a tool/function call");
+    }
+    async createResponsesRequest(body) {
+        const response = await fetch(`${this.config.baseUrl.replace(/\/$/, "")}/responses`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.config.apiKey}`,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            throw new Error(`OpenAI responses request failed: ${response.status} ${response.statusText}`);
+        }
+        return (await response.json());
+    }
+    async createChatCompletion(body) {
+        const response = await fetch(`${this.config.baseUrl.replace(/\/$/, "")}/chat/completions`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.config.apiKey}`,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            throw new Error(`OpenAI chat completions request failed: ${response.status} ${response.statusText}`);
+        }
+        return (await response.json());
+    }
+}
+function isAgentToolName(value) {
+    return (value === "noop" ||
+        value === "create_session" ||
+        value === "send_session_instruction" ||
+        value === "message_agent" ||
+        value === "notify_user" ||
+        value === "mark_project_complete");
+}
+function parseToolArguments(value) {
+    if (!value?.trim()) {
+        return {};
+    }
+    return JSON.parse(value);
+}
+function readMessageText(content) {
+    if (typeof content === "string") {
+        return content.trim();
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    return content
+        .map((item) => (typeof item?.text === "string" ? item.text : ""))
+        .join("")
+        .trim();
+}
+function readResponsesOutputText(payload) {
+    const outputParts = Array.isArray(payload.output)
+        ? payload.output
+            .flatMap((item) => Array.isArray(item.content)
+            ? item.content.map((content) => (typeof content?.text === "string" ? content.text : ""))
+            : [])
+            .filter(Boolean)
+        : [];
+    if (outputParts.length) {
+        return outputParts.join("").trim();
+    }
+    return typeof payload.output_text === "string" ? payload.output_text.trim() : "";
+}
+function omitDecisionMeta(input) {
+    const { action: _action, thought: _thought, stopReason: _stopReason, userFacingText: _userFacingText, ...rest } = input;
+    return rest;
+}
+function parseDecisionFromResponsesOutput(payload) {
+    const toolCall = payload.output?.find((item) => item?.type === "function_call" && typeof item?.name === "string");
+    if (!toolCall?.name) {
+        return null;
+    }
+    if (!isAgentToolName(toolCall.name)) {
+        throw new Error(`Unsupported agent tool: ${toolCall.name}`);
+    }
+    const parsedArgs = parseToolArguments(toolCall.arguments);
+    return buildDecision(toolCall.name, parsedArgs, readResponsesOutputText(payload));
+}
+function parseDecisionFromToolResponse(payload) {
+    const message = payload.choices?.[0]?.message;
+    const toolCall = message?.tool_calls?.[0];
+    if (!toolCall?.function?.name) {
+        return null;
+    }
+    const action = toolCall.function.name;
+    if (!isAgentToolName(action)) {
+        throw new Error(`Unsupported agent tool: ${toolCall.function.name}`);
+    }
+    const parsedArgs = parseToolArguments(toolCall.function.arguments);
+    return buildDecision(action, parsedArgs, readMessageText(message?.content));
+}
+function parseDecisionFromLegacyFunctionResponse(payload) {
+    const message = payload.choices?.[0]?.message;
+    const functionCall = message?.function_call;
+    if (!functionCall?.name) {
+        return null;
+    }
+    if (functionCall.name === "agent_decide") {
+        const parsedArgs = parseToolArguments(functionCall.arguments);
+        const action = typeof parsedArgs.action === "string" ? parsedArgs.action : "";
+        if (!isAgentToolName(action)) {
+            throw new Error(`Unsupported legacy agent action: ${action || functionCall.name}`);
+        }
+        return buildDecision(action, parsedArgs, readMessageText(message?.content));
+    }
+    if (!isAgentToolName(functionCall.name)) {
+        throw new Error(`Unsupported legacy function call: ${functionCall.name}`);
+    }
+    const parsedArgs = parseToolArguments(functionCall.arguments);
+    return buildDecision(functionCall.name, parsedArgs, readMessageText(message?.content));
+}
+function buildDecision(action, parsedArgs, contentText) {
+    const thought = typeof parsedArgs.thought === "string" && parsedArgs.thought.trim()
+        ? parsedArgs.thought.trim()
+        : contentText;
+    const actionInput = omitDecisionMeta(parsedArgs);
+    return {
+        thought,
+        action,
+        actionInput: Object.keys(actionInput).length ? actionInput : undefined,
+        stopReason: typeof parsedArgs.stopReason === "string" && parsedArgs.stopReason.trim()
+            ? parsedArgs.stopReason.trim()
+            : undefined,
+        userFacingText: typeof parsedArgs.userFacingText === "string" && parsedArgs.userFacingText.trim()
+            ? parsedArgs.userFacingText.trim()
+            : undefined,
+    };
+}
+function buildResponsesDecisionTools() {
+    return buildDecisionToolSpecs().map((tool) => ({
+        type: "function",
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters,
+    }));
+}
+function buildChatDecisionTools() {
+    return buildDecisionToolSpecs().map((tool) => ({
+        type: "function",
+        function: tool,
+    }));
+}
+function buildDecisionToolSpecs() {
+    return [
+        {
+            name: "noop",
+            description: "Use when no external action should be taken right now.",
+            parameters: {
+                type: "object",
+                properties: commonDecisionProperties(),
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "create_session",
+            description: "Create a new session for the project, optionally with an initial instruction.",
+            parameters: {
+                type: "object",
+                properties: {
+                    ...commonDecisionProperties(),
+                    cwd: { type: "string", description: "Working directory for the new session." },
+                    model: { type: "string", description: "Optional model override." },
+                    reasoningEffort: {
+                        type: "string",
+                        enum: ["none", "minimal", "low", "medium", "high", "xhigh"],
+                    },
+                    sandbox: {
+                        type: "string",
+                        enum: ["read-only", "workspace-write", "danger-full-access"],
+                    },
+                    approvalPolicy: {
+                        type: "string",
+                        enum: ["untrusted", "on-failure", "on-request", "never"],
+                    },
+                    instruction: {
+                        type: "string",
+                        description: "Optional first instruction to send to the new session immediately after creation.",
+                    },
+                },
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "send_session_instruction",
+            description: "Send an instruction to an existing session.",
+            parameters: {
+                type: "object",
+                properties: {
+                    ...commonDecisionProperties(),
+                    sessionId: {
+                        type: "string",
+                        description: "Target session id. Optional if this agent already has a bound session.",
+                    },
+                    instruction: {
+                        type: "string",
+                        description: "Instruction text to send to the target session.",
+                    },
+                },
+                required: ["instruction"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "message_agent",
+            description: "Send a message to another agent in the same project.",
+            parameters: {
+                type: "object",
+                properties: {
+                    ...commonDecisionProperties(),
+                    targetAgentId: { type: "string", description: "Target agent id." },
+                    text: { type: "string", description: "Message content." },
+                },
+                required: ["targetAgentId", "text"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "notify_user",
+            description: "Create a notification for the user, optionally via email.",
+            parameters: {
+                type: "object",
+                properties: {
+                    ...commonDecisionProperties(),
+                    severity: {
+                        type: "string",
+                        enum: ["info", "warning", "critical"],
+                    },
+                    channel: {
+                        type: "string",
+                        enum: ["inbox", "email"],
+                    },
+                    subject: { type: "string" },
+                    body: { type: "string" },
+                },
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "mark_project_complete",
+            description: "Mark the project as completed.",
+            parameters: {
+                type: "object",
+                properties: commonDecisionProperties(),
+                additionalProperties: false,
+            },
+        },
+    ];
+}
+function commonDecisionProperties() {
+    return {
+        thought: {
+            type: "string",
+            description: "Brief internal reasoning summary for the agent log.",
+        },
+        stopReason: {
+            type: "string",
+            description: "Why the agent is stopping or waiting after this action.",
+        },
+        userFacingText: {
+            type: "string",
+            description: "Optional concise text that can be surfaced to the user.",
+        },
+    };
+}
+function buildLegacyDecisionFunction() {
+    return {
+        name: "agent_decide",
+        description: "Choose the next agent action and provide its arguments.",
+        parameters: {
+            type: "object",
+            properties: {
+                ...commonDecisionProperties(),
+                action: {
+                    type: "string",
+                    enum: [
+                        "noop",
+                        "create_session",
+                        "send_session_instruction",
+                        "message_agent",
+                        "notify_user",
+                        "mark_project_complete",
+                    ],
+                },
+                cwd: { type: "string" },
+                model: { type: "string" },
+                reasoningEffort: {
+                    type: "string",
+                    enum: ["none", "minimal", "low", "medium", "high", "xhigh"],
+                },
+                sandbox: {
+                    type: "string",
+                    enum: ["read-only", "workspace-write", "danger-full-access"],
+                },
+                approvalPolicy: {
+                    type: "string",
+                    enum: ["untrusted", "on-failure", "on-request", "never"],
+                },
+                instruction: { type: "string" },
+                sessionId: { type: "string" },
+                text: { type: "string" },
+                targetAgentId: { type: "string" },
+                severity: {
+                    type: "string",
+                    enum: ["info", "warning", "critical"],
+                },
+                channel: {
+                    type: "string",
+                    enum: ["inbox", "email"],
+                },
+                subject: { type: "string" },
+                body: { type: "string" },
+            },
+            required: ["action"],
+            additionalProperties: false,
+        },
+    };
+}