doer-agent 0.6.5 → 0.6.7

package/dist/agent-codex-cli.js

@@ -55,6 +55,22 @@ export function buildDaemonMcpConfigArgs(args) {
         workspaceRootEnvName: "DOER_DAEMON_WORKSPACE_ROOT",
     });
 }
+export function buildMobileMcpConfigArgs(args) {
+    return buildWorkspaceMcpConfigArgs({
+        agentProjectDir: args.agentProjectDir,
+        workspaceRoot: args.workspaceRoot,
+        serverName: args.serverName?.trim() || "doer_mobile",
+        distEntryRelativePath: path.join("dist", "mobile-mcp-server.js"),
+        srcEntryRelativePath: path.join("src", "mobile-mcp-server.ts"),
+        workspaceRootEnvName: "DOER_MOBILE_WORKSPACE_ROOT",
+        env: {
+            DOER_MOBILE_SERVER_BASE_URL: args.serverBaseUrl,
+            DOER_MOBILE_USER_ID: args.userId,
+            DOER_MOBILE_AGENT_ID: args.agentId,
+            DOER_AGENT_TOKEN: args.agentToken,
+        },
+    });
+}
 function buildWorkspaceMcpConfigArgs(args) {
     const serverName = args.serverName.trim();
     const distEntry = path.join(args.agentProjectDir, args.distEntryRelativePath);
@@ -64,7 +80,7 @@ function buildWorkspaceMcpConfigArgs(args) {
     const commandArgs = existsSync(distEntry)
         ? [distEntry, "--workspace-root", args.workspaceRoot]
         : ["--import", tsxLoaderPath, srcEntry, "--workspace-root", args.workspaceRoot];
-    return [
+    const configArgs = [
         "--config",
         `mcp_servers.${serverName}.command=${toTomlStringLiteral(command)}`,
         "--config",
@@ -74,6 +90,10 @@ function buildWorkspaceMcpConfigArgs(args) {
         "--config",
         `mcp_servers.${serverName}.enabled=true`,
     ];
+    for (const [key, value] of Object.entries(args.env ?? {})) {
+        configArgs.push("--config", `mcp_servers.${serverName}.env.${key}=${toTomlStringLiteral(value)}`);
+    }
+    return configArgs;
 }
 export function buildLocalCodexCliCommand(args) {
     const quotedArgs = args.map(shellSingleQuote).join(" ");

package/dist/agent-settings.js

@@ -17,6 +17,7 @@ export function createDefaultAgentSettingsConfig() {
         codex: {
             model: "gpt-5.5",
             reasoningEffort: "medium",
+            serviceTier: null,
             authMode: "api_key",
             computerUseEnabled: false,
             browserUseEnabled: false,
@@ -52,6 +53,13 @@ function normalizeNullableString(value) {
     const trimmed = value.trim();
     return trimmed ? trimmed : null;
 }
+function normalizeServiceTier(value) {
+    const normalized = normalizeNullableString(value);
+    if (normalized === "priority") {
+        return "fast";
+    }
+    return normalized;
+}
 function normalizeCodexPersonality(value, fallback) {
     return value === "friendly" || value === "pragmatic" ? value : fallback;
 }
@@ -122,6 +130,7 @@ export function normalizeAgentSettingsConfig(value, fallback) {
         codex: {
             model: typeof codex.model === "string" && codex.model.trim() ? codex.model.trim() : base.codex.model,
             reasoningEffort: normalizeReasoningEffort(codex.reasoningEffort, base.codex.reasoningEffort),
+            serviceTier: codex.serviceTier === null ? null : normalizeServiceTier(codex.serviceTier) ?? base.codex.serviceTier,
             authMode: codex.authMode === "chatgpt" ? "chatgpt" : codex.authMode === "api_key" ? "api_key" : base.codex.authMode,
             computerUseEnabled: typeof codex.computerUseEnabled === "boolean" ? codex.computerUseEnabled : base.codex.computerUseEnabled,
             browserUseEnabled: typeof codex.browserUseEnabled === "boolean" ? codex.browserUseEnabled : base.codex.browserUseEnabled,
@@ -202,6 +211,7 @@ export async function toAgentSettingsPublic(args) {
         codex: {
             model: args.config.codex.model,
             reasoningEffort: args.config.codex.reasoningEffort,
+            serviceTier: args.config.codex.serviceTier,
             authMode: args.config.codex.authMode,
             computerUseEnabled: args.config.codex.computerUseEnabled,
             browserUseEnabled: args.config.codex.browserUseEnabled,
@@ -260,6 +270,7 @@ export function normalizeAgentSettingsPatch(value) {
     move("personality", "general", "personality");
     move("codexModel", "codex", "model");
     move("codexReasoningEffort", "codex", "reasoningEffort");
+    move("codexServiceTier", "codex", "serviceTier");
     move("codexAuthMode", "codex", "authMode");
     move("computerUseEnabled", "codex", "computerUseEnabled");
     move("browserUseEnabled", "codex", "browserUseEnabled");

package/dist/agent.js

@@ -224,10 +224,14 @@ async function main() {
             heartbeatAgentSession: heartbeatSession,
             subscribeAll: () => {
                 const codexAppServerManager = createCodexAppServerManager({
+                    agentId: initialAgentId,
+                    agentToken,
                     workspaceRoot: resolveWorkspaceRoot(),
                     agentProjectDir: AGENT_PROJECT_DIR,
+                    serverBaseUrl,
                     resolveCodexHomePath: runtimeEnvHelpers.resolveCodexHomePath,
                     readAgentSettingsConfig,
+                    userId,
                     onLog: writeAgentInfo,
                     onNotification: (method, params) => {
                         if (!shouldForwardCodexAppNotification(method)) {

package/dist/codex-app-server-manager.js

@@ -1,5 +1,5 @@
 import { buildAgentSettingsEnvPatch, readAgentModelInstructions, resolveAgentModelInstructionsFilePath, } from "./agent-settings.js";
-import { buildDaemonMcpConfigArgs } from "./agent-codex-cli.js";
+import { buildDaemonMcpConfigArgs, buildMobileMcpConfigArgs } from "./agent-codex-cli.js";
 import { CodexAppServerClient } from "./codex-app-server-client.js";
 function toTomlStringLiteral(value) {
     return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
@@ -14,6 +14,9 @@ async function buildCodexAppServerArgs(args) {
     const configArgs = [
         ...buildConfigArg("model", toTomlStringLiteral(args.settings.codex.model)),
         ...buildConfigArg("model_reasoning_effort", toTomlStringLiteral(args.settings.codex.reasoningEffort)),
+        ...(args.settings.codex.serviceTier
+            ? buildConfigArg("service_tier", toTomlStringLiteral(args.settings.codex.serviceTier))
+            : []),
         ...buildConfigArg("personality", toTomlStringLiteral(args.settings.general.personality)),
         ...buildConfigArg("approval_policy", toTomlStringLiteral("never")),
         ...buildConfigArg("sandbox_mode", toTomlStringLiteral("danger-full-access")),
@@ -29,6 +32,14 @@ async function buildCodexAppServerArgs(args) {
             agentProjectDir: args.agentProjectDir,
             workspaceRoot: args.workspaceRoot,
         }),
+        ...buildMobileMcpConfigArgs({
+            agentId: args.agentId,
+            agentProjectDir: args.agentProjectDir,
+            agentToken: args.agentToken,
+            serverBaseUrl: args.serverBaseUrl,
+            userId: args.userId,
+            workspaceRoot: args.workspaceRoot,
+        }),
         ...buildFeatureArg(true, "goals"),
         ...buildFeatureArg(args.settings.codex.computerUseEnabled, "computer_use"),
         ...buildFeatureArg(args.settings.codex.browserUseEnabled, "browser_use"),
@@ -41,6 +52,10 @@ async function buildCodexAppServerEnv(args) {
         ...process.env,
         ...buildAgentSettingsEnvPatch(args.settings),
         CODEX_HOME: args.resolveCodexHomePath(),
+        DOER_AGENT_TOKEN: args.agentToken,
+        DOER_MOBILE_AGENT_ID: args.agentId,
+        DOER_MOBILE_SERVER_BASE_URL: args.serverBaseUrl,
+        DOER_MOBILE_USER_ID: args.userId,
     };
 }
 export function createCodexAppServerManager(args) {
@@ -50,14 +65,22 @@ export function createCodexAppServerManager(args) {
     const createClient = async () => {
         const settings = await args.readAgentSettingsConfig({ workspaceRoot: args.workspaceRoot });
         const appServerArgs = await buildCodexAppServerArgs({
+            agentId: args.agentId,
+            agentToken: args.agentToken,
             workspaceRoot: args.workspaceRoot,
             agentProjectDir: args.agentProjectDir,
+            serverBaseUrl: args.serverBaseUrl,
             settings,
+            userId: args.userId,
         });
         const env = await buildCodexAppServerEnv({
+            agentId: args.agentId,
+            agentToken: args.agentToken,
             workspaceRoot: args.workspaceRoot,
+            serverBaseUrl: args.serverBaseUrl,
             resolveCodexHomePath: args.resolveCodexHomePath,
             settings,
+            userId: args.userId,
         });
         args.onLog?.(`starting codex app-server model=${settings.codex.model} reasoningEffort=${settings.codex.reasoningEffort} personality=${settings.general.personality} computerUse=${settings.codex.computerUseEnabled} browserUse=${settings.codex.browserUseEnabled}`);
         return new CodexAppServerClient({

package/dist/mobile-mcp-server.js

@@ -0,0 +1,254 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import * as z from "zod/v4";
+function env(name) {
+    const value = process.env[name]?.trim() || "";
+    if (!value) {
+        throw new Error(`${name} is required`);
+    }
+    return value;
+}
+function optionalEnv(name) {
+    return process.env[name]?.trim() || "";
+}
+function formatJson(value) {
+    return JSON.stringify(value, null, 2);
+}
+function normalizeLimit(value, fallback, max) {
+    if (!Number.isFinite(value) || !value) {
+        return fallback;
+    }
+    return Math.min(max, Math.max(1, Math.trunc(value)));
+}
+function getConfig() {
+    return {
+        agentId: env("DOER_MOBILE_AGENT_ID"),
+        agentToken: env("DOER_AGENT_TOKEN"),
+        serverBaseUrl: env("DOER_MOBILE_SERVER_BASE_URL").replace(/\/$/, ""),
+        userId: env("DOER_MOBILE_USER_ID"),
+    };
+}
+async function requestJson(path) {
+    const config = getConfig();
+    const response = await fetch(`${config.serverBaseUrl}${path}`, {
+        headers: {
+            Authorization: `Bearer ${config.agentToken}`,
+            Accept: "application/json",
+        },
+    });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) {
+        throw new Error(typeof data.error === "string" ? data.error : `Doer server returned ${response.status}`);
+    }
+    return data;
+}
+async function listMobileAgents() {
+    const config = getConfig();
+    const data = await requestJson(`/api/users/${encodeURIComponent(config.userId)}/agents/${encodeURIComponent(config.agentId)}/mobile-agents`);
+    return Array.isArray(data.mobileAgents) ? data.mobileAgents : [];
+}
+async function resolveDeviceId(deviceId) {
+    const normalized = deviceId?.trim() || "";
+    if (normalized) {
+        return normalized;
+    }
+    const mobileAgents = await listMobileAgents();
+    const first = mobileAgents[0]?.deviceId?.trim() || "";
+    if (!first) {
+        throw new Error("No mobile agents registered");
+    }
+    return first;
+}
+async function getMobileInfo(deviceId) {
+    const config = getConfig();
+    const resolvedDeviceId = await resolveDeviceId(deviceId);
+    return await requestJson(`/api/users/${encodeURIComponent(config.userId)}/agents/${encodeURIComponent(config.agentId)}/mobile-agents/${encodeURIComponent(resolvedDeviceId)}/info`);
+}
+async function getMobileLogs(args) {
+    const config = getConfig();
+    const resolvedDeviceId = await resolveDeviceId(args.deviceId);
+    const qs = new URLSearchParams({
+        limit: String(normalizeLimit(args.limit, 100, 1000)),
+    });
+    if (Number.isInteger(args.beforeSeq)) {
+        qs.set("beforeSeq", String(args.beforeSeq));
+    }
+    if (Number.isInteger(args.afterSeq)) {
+        qs.set("afterSeq", String(args.afterSeq));
+    }
+    const data = await requestJson(`/api/users/${encodeURIComponent(config.userId)}/agents/${encodeURIComponent(config.agentId)}/mobile-agents/${encodeURIComponent(resolvedDeviceId)}/events?${qs.toString()}`);
+    return {
+        events: Array.isArray(data.events) ? data.events : [],
+        hasMore: data.hasMore === true,
+        latestSeq: typeof data.latestSeq === "number" ? data.latestSeq : null,
+        nextBeforeSeq: typeof data.nextBeforeSeq === "number" ? data.nextBeforeSeq : null,
+    };
+}
+async function searchMobileLogs(args) {
+    const config = getConfig();
+    const resolvedDeviceId = await resolveDeviceId(args.deviceId);
+    const qs = new URLSearchParams({
+        limit: String(normalizeLimit(args.limit, 100, 1000)),
+    });
+    if (args.kind?.trim()) {
+        qs.set("kind", args.kind.trim());
+    }
+    if (args.query?.trim()) {
+        qs.set("query", args.query.trim());
+    }
+    if (args.since?.trim()) {
+        qs.set("since", args.since.trim());
+    }
+    if (args.until?.trim()) {
+        qs.set("until", args.until.trim());
+    }
+    if (Number.isInteger(args.beforeSeq)) {
+        qs.set("beforeSeq", String(args.beforeSeq));
+    }
+    if (Number.isInteger(args.afterSeq)) {
+        qs.set("afterSeq", String(args.afterSeq));
+    }
+    const data = await requestJson(`/api/users/${encodeURIComponent(config.userId)}/agents/${encodeURIComponent(config.agentId)}/mobile-agents/${encodeURIComponent(resolvedDeviceId)}/events?${qs.toString()}`);
+    return {
+        events: Array.isArray(data.events) ? data.events : [],
+        hasMore: data.hasMore === true,
+        latestSeq: typeof data.latestSeq === "number" ? data.latestSeq : null,
+        nextBeforeSeq: typeof data.nextBeforeSeq === "number" ? data.nextBeforeSeq : null,
+    };
+}
+function extractLatestLocation(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event?.kind === "location.current" || event?.kind === "location.changed") {
+            return event;
+        }
+    }
+    return null;
+}
+function extractLocationEvents(events) {
+    return events.filter((event) => event.kind.startsWith("location."));
+}
+function extractNotifications(events) {
+    return events.filter((event) => event.kind.startsWith("notification."));
+}
+async function main() {
+    const server = new McpServer({
+        name: "doer-mobile",
+        version: "0.1.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+        instructions: "Inspect mobile agents paired with the current Doer agent. Use these tools to list devices, poll cursor-based logs, and inspect latest location/notification context.",
+    });
+    server.registerTool("mobile_list", {
+        description: "List mobile agents paired with the current Doer agent.",
+        inputSchema: {},
+    }, async () => {
+        const mobileAgents = await listMobileAgents();
+        return {
+            content: [{ type: "text", text: formatJson({ mobileAgents }) }],
+            structuredContent: { mobileAgents },
+        };
+    });
+    server.registerTool("mobile_info", {
+        description: "Read info for a mobile agent. Defaults to the first registered device.",
+        inputSchema: {
+            deviceId: z.string().optional().describe("Mobile device id. Defaults to the first registered mobile agent."),
+        },
+    }, async ({ deviceId }) => {
+        const result = await getMobileInfo(deviceId);
+        return {
+            content: [{ type: "text", text: formatJson(result) }],
+            structuredContent: result,
+        };
+    });
+    server.registerTool("mobile_logs", {
+        description: "Read a cursor-based page of mobile log events from the device-local SQLite log.",
+        inputSchema: {
+            afterSeq: z.number().int().min(0).optional().describe("Return events newer than this seq, in ascending order."),
+            beforeSeq: z.number().int().min(1).optional().describe("Return events older than this seq, in ascending order."),
+            deviceId: z.string().optional().describe("Mobile device id. Defaults to the first registered mobile agent."),
+            limit: z.number().int().min(1).max(1000).optional().describe("Maximum number of recent events."),
+        },
+    }, async ({ afterSeq, beforeSeq, deviceId, limit }) => {
+        const page = await getMobileLogs({ afterSeq, beforeSeq, deviceId, limit });
+        return {
+            content: [{ type: "text", text: formatJson(page) }],
+            structuredContent: page,
+        };
+    });
+    server.registerTool("mobile_search_logs", {
+        description: "Search the device-local mobile SQLite event log by kind, text query, cursor, and observed time range.",
+        inputSchema: {
+            afterSeq: z.number().int().min(0).optional().describe("Return matching events newer than this seq, in ascending order."),
+            beforeSeq: z.number().int().min(1).optional().describe("Return matching events older than this seq, in ascending order."),
+            deviceId: z.string().optional().describe("Mobile device id. Defaults to the first registered mobile agent."),
+            kind: z.string().optional().describe("Event kind or kind prefix, such as location.current or notification."),
+            query: z.string().optional().describe("Case-insensitive text to search in the event kind or payload."),
+            since: z.string().optional().describe("Inclusive ISO timestamp lower bound."),
+            until: z.string().optional().describe("Inclusive ISO timestamp upper bound."),
+            limit: z.number().int().min(1).max(1000).optional().describe("Maximum number of matching events."),
+        },
+    }, async ({ afterSeq, beforeSeq, deviceId, kind, query, since, until, limit }) => {
+        const page = await searchMobileLogs({ afterSeq, beforeSeq, deviceId, kind, query, since, until, limit });
+        return {
+            content: [{ type: "text", text: formatJson(page) }],
+            structuredContent: page,
+        };
+    });
+    server.registerTool("mobile_latest_location", {
+        description: "Return the latest location event from recent mobile logs.",
+        inputSchema: {
+            deviceId: z.string().optional().describe("Mobile device id. Defaults to the first registered mobile agent."),
+            limit: z.number().int().min(1).max(1000).optional().describe("How many recent events to scan."),
+        },
+    }, async ({ deviceId, limit }) => {
+        const page = await searchMobileLogs({ deviceId, kind: "location.", limit: limit ?? 200 });
+        const location = extractLatestLocation(page.events);
+        return {
+            content: [{ type: "text", text: formatJson({ location }) }],
+            structuredContent: { location },
+        };
+    });
+    server.registerTool("mobile_location_history", {
+        description: "Return time-range location events recorded by the mobile agent.",
+        inputSchema: {
+            afterSeq: z.number().int().min(0).optional().describe("Return location events newer than this seq, in ascending order."),
+            beforeSeq: z.number().int().min(1).optional().describe("Return location events older than this seq, in ascending order."),
+            deviceId: z.string().optional().describe("Mobile device id. Defaults to the first registered mobile agent."),
+            since: z.string().optional().describe("Inclusive ISO timestamp lower bound."),
+            until: z.string().optional().describe("Inclusive ISO timestamp upper bound."),
+            limit: z.number().int().min(1).max(1000).optional().describe("Maximum number of matching location events."),
+        },
+    }, async ({ afterSeq, beforeSeq, deviceId, since, until, limit }) => {
+        const page = await searchMobileLogs({ afterSeq, beforeSeq, deviceId, kind: "location.", since, until, limit: limit ?? 200 });
+        const events = extractLocationEvents(page.events);
+        const result = { ...page, events };
+        return {
+            content: [{ type: "text", text: formatJson(result) }],
+            structuredContent: result,
+        };
+    });
+    server.registerTool("mobile_notifications", {
+        description: "Return recent notification events from mobile logs.",
+        inputSchema: {
+            deviceId: z.string().optional().describe("Mobile device id. Defaults to the first registered mobile agent."),
+            limit: z.number().int().min(1).max(1000).optional().describe("How many recent events to scan."),
+        },
+    }, async ({ deviceId, limit }) => {
+        const page = await searchMobileLogs({ deviceId, kind: "notification.", limit: limit ?? 200 });
+        const events = extractNotifications(page.events);
+        return {
+            content: [{ type: "text", text: formatJson({ events }) }],
+            structuredContent: { events },
+        };
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.stack || error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doer-agent",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",