@dobby.ai/dobby 0.1.1 → 0.1.2

package/README.md

@@ -7,6 +7,7 @@ Discord-first 本地 Agent Gateway。宿主只负责 CLI、网关主流程、扩
 - `@dobby.ai/connector-discord`
 - `@dobby.ai/connector-feishu`
 - `@dobby.ai/provider-pi`
+- `@dobby.ai/provider-codex-cli`
 - `@dobby.ai/provider-claude-cli`
 - `@dobby.ai/provider-claude`
 - `@dobby.ai/sandbox-core`
@@ -59,7 +60,7 @@ Discord / Cron
 - npm
 - 对应 provider / connector 的外部运行条件
   - 例如 Discord bot token
-  - Claude CLI 或 Claude Agent SDK 所需认证
+  - Codex CLI、Claude CLI 或 Claude Agent SDK 所需认证
   - 可选的 Docker / Boxlite 运行环境
 
 ## 快速开始
@@ -245,10 +246,6 @@ dobby cron remove <jobId>
   - 未指定时默认使用 `host.builtin`
 - 未匹配 binding 的入站消息会被直接忽略；仅 direct message 可回落到 `bindings.default`
 
-当前代码还保留但未真正生效的字段：
-
-- cron job 的 `sessionPolicy`
-
 示例配置：
 
 - gateway：[`config/gateway.example.json`](config/gateway.example.json)
@@ -278,6 +275,7 @@ dobby cron remove <jobId>
 
 - `connector.discord`
 - `provider.pi`
+- `provider.codex-cli`
 - `provider.claude-cli`
 - `provider.claude`
 - `sandbox.boxlite`
@@ -288,13 +286,28 @@ dobby cron remove <jobId>
 - provider：`provider.pi`、`provider.claude-cli`
 - connector：`connector.discord`、`connector.feishu`
 
-`provider.claude` 与 sandbox 相关扩展需要手工安装和配置，例如：
+`provider.codex-cli`、`provider.claude` 与 sandbox 相关扩展需要手工安装和配置，例如：
 
 ```bash
+npm run start -- extension install @dobby.ai/provider-codex-cli --enable
 npm run start -- extension install @dobby.ai/provider-claude --enable
 npm run start -- extension install @dobby.ai/sandbox-core --enable
 ```
 
+若使用 `provider.codex-cli`，启动前建议检查：
+
+```bash
+codex --version
+codex login status
+```
+
+最小配置字段：
+
+- `command`（默认 `codex`）
+- `commandArgs`（默认 `[]`）
+- `model`（可选；未设置时使用 Codex CLI / 本地配置默认模型）
+- `skipGitRepoCheck`（默认 `false`）
+
 `--enable` 的行为：
 
 - 把包写入 `extensions.allowList`
@@ -323,7 +336,7 @@ npm run start -- cron add daily-report \
 
 说明：
 
-- `cron run <jobId>` 只是把 job 标记为“下一次 scheduler tick 执行”
+- `cron run <jobId>` 会额外排队一次立即执行，不会恢复 paused 状态，也不会改写原有 `nextRunAtMs`
 - 需要已有一个正在运行的 `dobby start`
 - 当前 scheduled run 一律按 stateless / ephemeral 执行
 

package/dist/src/agent/event-forwarder.js

@@ -1,3 +1,11 @@
+import { OUTBOUND_MESSAGE_KIND_METADATA_KEY, OUTBOUND_MESSAGE_KIND_PROGRESS, } from "../core/types.js";
+const DEFAULT_PROGRESS_DEBOUNCE_MS = 150;
+const DEFAULT_LONG_PROGRESS_MS = 10_000;
+const WORKING_LOCALLY_TEXT = "Working locally...";
+const STILL_WORKING_LOCALLY_TEXT = "Still working locally...";
+const WORKING_WITH_TOOLS_TEXT = "Working with tools...";
+const STILL_WORKING_WITH_TOOLS_TEXT = "Still working with tools...";
+const RECOVERING_FROM_TOOL_ISSUE_TEXT = "Recovering from a tool issue...";
 function truncate(text, max) {
     if (max === undefined)
         return text;
@@ -57,22 +65,37 @@ export class EventForwarder {
     appendEmittedText = "";
     pendingFlush = null;
     flushSerial = Promise.resolve();
+    progressSerial = Promise.resolve();
     pendingOps = [];
     updateIntervalMs;
+    progressDebounceMs;
+    longProgressMs;
     toolMessageMode;
     maxTextLength;
     onOutboundActivity;
     updateStrategy;
+    progressUpdateStrategy;
     lastEditPrimaryText = null;
+    progressMessageId = null;
+    lastProgressMessageText = null;
+    pendingProgressText = null;
+    pendingProgressFlush = null;
+    hasQueuedProgressMessage = false;
+    longProgressTimer = null;
+    activeWorkPhase = null;
     constructor(connector, inbound, rootMessageId, logger, options = {}) {
         this.connector = connector;
         this.inbound = inbound;
         this.logger = logger;
         this.rootMessageId = rootMessageId;
         this.updateIntervalMs = options.updateIntervalMs ?? 400;
+        this.progressDebounceMs = options.progressDebounceMs ?? DEFAULT_PROGRESS_DEBOUNCE_MS;
+        this.longProgressMs = options.longProgressMs ?? DEFAULT_LONG_PROGRESS_MS;
         this.toolMessageMode = options.toolMessageMode ?? "none";
         this.onOutboundActivity = options.onOutboundActivity;
         this.updateStrategy = this.connector.capabilities.updateStrategy;
+        this.progressUpdateStrategy = this.connector.capabilities.progressUpdateStrategy
+            ?? (this.updateStrategy === "edit" ? "edit" : "create");
         const capabilityMaxTextLength = this.connector.capabilities.maxTextLength;
         this.maxTextLength = typeof capabilityMaxTextLength === "number" && capabilityMaxTextLength > 0
             ? capabilityMaxTextLength
@@ -98,13 +121,20 @@ export class EventForwarder {
             }
             return;
         }
+        if (event.type === "command_start") {
+            this.enterWorkPhase("local");
+            return;
+        }
         if (event.type === "tool_start") {
             this.logger.info({
                 toolName: event.toolName,
                 conversation: `${this.inbound.platform}:${this.inbound.accountId}:${this.inbound.chatId}:${this.inbound.threadId ?? "root"}`,
             }, "Tool execution started");
-            if (this.updateStrategy !== "final_only" && this.toolMessageMode === "all") {
-                this.enqueueSend(`_-> Running tool: ${event.toolName}_`);
+            if (this.toolMessageMode === "all") {
+                this.enqueueSideMessage(this.renderToolStartMessage(event.toolName));
+            }
+            else {
+                this.enterWorkPhase("tool");
             }
             return;
         }
@@ -115,26 +145,21 @@ export class EventForwarder {
                 isError: event.isError,
                 conversation: `${this.inbound.platform}:${this.inbound.accountId}:${this.inbound.chatId}:${this.inbound.threadId ?? "root"}`,
             }, event.isError ? "Tool execution finished with error" : "Tool execution finished");
-            if (this.updateStrategy !== "final_only" &&
-                (this.toolMessageMode === "all" || (this.toolMessageMode === "errors" && event.isError))) {
-                const prefix = event.isError ? "ERR" : "OK";
-                const header = `*${prefix} ${event.toolName}*\n\`\`\`\n`;
-                const footer = "\n```";
-                const availableSummaryLength = this.maxTextLength === undefined
-                    ? undefined
-                    : Math.max(0, this.maxTextLength - header.length - footer.length);
-                this.enqueueSend(`${header}${truncate(summary, availableSummaryLength)}${footer}`);
+            if ((this.toolMessageMode === "all" || (this.toolMessageMode === "errors" && event.isError))) {
+                this.enqueueSideMessage(this.renderToolEndMessage(event.toolName, event.isError, summary));
+            }
+            else if (event.isError) {
+                this.setProgressMessage(RECOVERING_FROM_TOOL_ISSUE_TEXT);
             }
             return;
         }
         if (event.type === "status") {
-            if (this.updateStrategy === "final_only") {
-                return;
-            }
-            this.enqueueSend(`_${event.message}_`);
+            this.setProgressMessage(event.message);
         }
     };
     async finalize() {
+        this.clearLongProgressTimer();
+        await this.flushProgressUpdates();
         if (this.updateStrategy === "final_only") {
             await this.finalizeFinalOnly();
             await Promise.allSettled(this.pendingOps);
@@ -173,6 +198,7 @@ export class EventForwarder {
                 return;
             }
             try {
+                await this.flushProgressUpdates();
                 if (this.updateStrategy === "append") {
                     await this.flushAppendProgress();
                     return;
@@ -198,13 +224,113 @@ export class EventForwarder {
         });
         await run;
     }
-    enqueueSend(text) {
+    enqueueSideMessage(text) {
+        this.enqueueSendWithMetadata(text, this.progressMessageMetadata());
+    }
+    setProgressMessage(message) {
+        this.activeWorkPhase = null;
+        this.clearLongProgressTimer();
+        this.scheduleProgressUpdate(this.renderStatusMessage(message));
+    }
+    enterWorkPhase(phase) {
+        if (this.activeWorkPhase === "local" && phase === "tool") {
+            return;
+        }
+        if (this.activeWorkPhase === phase) {
+            return;
+        }
+        this.activeWorkPhase = phase;
+        this.scheduleProgressUpdate(this.renderWorkPhaseMessage(phase, false));
+        this.scheduleLongProgressUpdate(phase);
+    }
+    scheduleProgressUpdate(text) {
+        const shouldCreateImmediately = !this.hasQueuedProgressMessage;
+        this.hasQueuedProgressMessage = true;
+        this.pendingProgressText = text;
+        if (shouldCreateImmediately) {
+            void this.flushProgressNow();
+            return;
+        }
+        if (this.pendingProgressFlush) {
+            clearTimeout(this.pendingProgressFlush);
+        }
+        this.pendingProgressFlush = setTimeout(() => {
+            void this.flushProgressNow();
+        }, this.progressDebounceMs);
+    }
+    async flushProgressNow() {
+        if (this.pendingProgressFlush) {
+            clearTimeout(this.pendingProgressFlush);
+            this.pendingProgressFlush = null;
+        }
+        const text = this.pendingProgressText;
+        if (text === null) {
+            return;
+        }
+        this.pendingProgressText = null;
+        const metadata = this.progressMessageMetadata();
+        const run = this.progressSerial.then(async () => {
+            if (this.lastProgressMessageText === text) {
+                return;
+            }
+            try {
+                if (this.canEditProgressMessage() && this.progressMessageId) {
+                    await this.connector.send({
+                        ...this.baseEnvelope(),
+                        mode: "update",
+                        targetMessageId: this.progressMessageId,
+                        text,
+                        metadata,
+                    });
+                    this.lastProgressMessageText = text;
+                    this.noteOutboundActivity();
+                    return;
+                }
+                const created = await this.connector.send({
+                    ...this.baseEnvelope(),
+                    mode: "create",
+                    text,
+                    metadata,
+                });
+                this.progressMessageId = this.canEditProgressMessage() ? (created.messageId ?? this.progressMessageId) : null;
+                this.lastProgressMessageText = text;
+                this.noteOutboundActivity();
+            }
+            catch (error) {
+                this.logger.warn({
+                    err: error,
+                    connectorId: this.inbound.connectorId,
+                    chatId: this.inbound.chatId,
+                    progressMessageId: this.progressMessageId,
+                }, "Failed to send or update progress message");
+            }
+        });
+        this.progressSerial = run.catch(() => {
+            // keep chain alive for future progress updates
+        });
+        this.pendingOps.push(run);
+        await run;
+    }
+    scheduleLongProgressUpdate(phase) {
+        this.clearLongProgressTimer();
+        if (this.longProgressMs <= 0) {
+            return;
+        }
+        this.longProgressTimer = setTimeout(() => {
+            if (this.activeWorkPhase !== phase) {
+                return;
+            }
+            this.scheduleProgressUpdate(this.renderWorkPhaseMessage(phase, true));
+        }, this.longProgressMs);
+    }
+    enqueueSendWithMetadata(text, metadata) {
         const promise = this.connector
             .send({
             ...this.baseEnvelope(),
             mode: "create",
             ...(this.rootMessageId ? { replyToMessageId: this.rootMessageId } : {}),
             text,
+            ...(metadata ? { metadata } : {}),
         })
             .then(() => {
             this.noteOutboundActivity();
@@ -219,6 +345,49 @@ export class EventForwarder {
         });
         this.pendingOps.push(promise);
     }
+    canEditProgressMessage() {
+        return this.progressUpdateStrategy === "edit";
+    }
+    progressMessageMetadata() {
+        return {
+            [OUTBOUND_MESSAGE_KIND_METADATA_KEY]: OUTBOUND_MESSAGE_KIND_PROGRESS,
+        };
+    }
+    renderStatusMessage(message) {
+        return truncate(message, this.maxTextLength);
+    }
+    renderWorkPhaseMessage(phase, isLongRunning) {
+        if (phase === "local") {
+            return truncate(isLongRunning ? STILL_WORKING_LOCALLY_TEXT : WORKING_LOCALLY_TEXT, this.maxTextLength);
+        }
+        return truncate(isLongRunning ? STILL_WORKING_WITH_TOOLS_TEXT : WORKING_WITH_TOOLS_TEXT, this.maxTextLength);
+    }
+    renderToolStartMessage(toolName) {
+        return truncate(`Running tool: ${toolName}`, this.maxTextLength);
+    }
+    renderToolEndMessage(toolName, isError, summary) {
+        const prefix = isError ? "ERR" : "OK";
+        const body = summary.trim().length > 0 ? `${prefix} ${toolName}\n${summary}` : `${prefix} ${toolName}`;
+        return truncate(body, this.maxTextLength);
+    }
+    async flushProgressUpdates() {
+        if (this.pendingProgressText !== null) {
+            await this.flushProgressNow();
+            return;
+        }
+        try {
+            await this.progressSerial;
+        }
+        catch {
+            // progress message failures are already logged when they happen
+        }
+    }
+    clearLongProgressTimer() {
+        if (this.longProgressTimer) {
+            clearTimeout(this.longProgressTimer);
+            this.longProgressTimer = null;
+        }
+    }
     async sendEditPrimary(text) {
         if (this.rootMessageId && this.lastEditPrimaryText === text) {
             return;

package/dist/src/cli/commands/cron.js

@@ -36,15 +36,6 @@ function parseSchedule(input) {
         ...(input.tz ? { tz: input.tz } : {}),
     };
 }
-function parseSessionPolicy(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (value === "stateless" || value === "shared-session") {
-        return value;
-    }
-    throw new Error(`Invalid session policy '${value}'. Expected 'stateless' or 'shared-session'.`);
-}
 function assertDeliveryReferences(config, input) {
     if (!config.connectors.items[input.connectorId]) {
         throw new Error(`Unknown connectorId '${input.connectorId}'`);
@@ -86,13 +77,11 @@ export async function runCronAddCommand(options) {
     const now = Date.now();
     const nextRunAtMs = computeInitialNextRunAtMs(schedule, now);
     const id = `${slugify(options.name)}-${Math.random().toString(36).slice(2, 8)}`;
-    const sessionPolicy = parseSessionPolicy(options.sessionPolicy) ?? "stateless";
     const job = {
         id,
         name: options.name,
         enabled: true,
         schedule,
-        sessionPolicy,
         prompt: options.prompt,
         delivery: {
             connectorId: options.connectorId,
@@ -132,6 +121,9 @@ export async function runCronListCommand(options) {
         console.log(`- ${job.id} [${job.enabled ? "enabled" : "paused"}] ${job.name}`);
         console.log(`  schedule=${schedule}`);
         console.log(`  next=${next} last=${last} status=${job.state.lastStatus ?? "-"}`);
+        if (job.state.manualRunRequestedAtMs !== undefined) {
+            console.log(`  manualRun=${new Date(job.state.manualRunRequestedAtMs).toISOString()}`);
+        }
         console.log(`  delivery=${job.delivery.connectorId}/${job.delivery.routeId}/${job.delivery.channelId}`);
     }
 }
@@ -154,10 +146,12 @@ export async function runCronStatusCommand(options) {
         console.log(`- name: ${target.name}`);
         console.log(`- enabled: ${target.enabled}`);
         console.log(`- schedule: ${describeSchedule(target.schedule)}`);
-        console.log(`- sessionPolicy: ${target.sessionPolicy ?? "stateless"}`);
         console.log(`- nextRun: ${target.state.nextRunAtMs ? new Date(target.state.nextRunAtMs).toISOString() : "-"}`);
         console.log(`- lastRun: ${target.state.lastRunAtMs ? new Date(target.state.lastRunAtMs).toISOString() : "-"}`);
         console.log(`- lastStatus: ${target.state.lastStatus ?? "-"}`);
+        if (target.state.manualRunRequestedAtMs !== undefined) {
+            console.log(`- manualRunQueuedAt: ${new Date(target.state.manualRunRequestedAtMs).toISOString()}`);
+        }
         if (target.state.lastError) {
             console.log(`- lastError: ${target.state.lastError}`);
         }
@@ -173,28 +167,23 @@ export async function runCronRunCommand(options) {
     const now = Date.now();
     await context.store.updateJob(options.jobId, (current) => ({
         ...current,
-        enabled: true,
         updatedAtMs: now,
         state: {
             ...current.state,
-            nextRunAtMs: now,
+            manualRunRequestedAtMs: current.state.manualRunRequestedAtMs ?? now,
         },
     }));
-    console.log(`Scheduled cron job ${options.jobId} to run on next scheduler tick.`);
+    console.log(`Queued one manual run for cron job ${options.jobId}.`);
+    console.log("It will execute once without changing the job's enabled state or next scheduled run.");
     console.log("Ensure the gateway process is running for execution.");
 }
 export async function runCronUpdateCommand(options) {
     const context = await loadCronContext(options.cronConfigPath ? { cronConfigPath: options.cronConfigPath } : undefined);
     const now = Date.now();
-    const hasScheduleUpdate = options.at !== undefined || options.everyMs !== undefined || options.cronExpr !== undefined;
-    const nextSchedule = hasScheduleUpdate
-        ? parseSchedule({
-            ...(options.at ? { at: options.at } : {}),
-            ...(options.everyMs !== undefined ? { everyMs: options.everyMs } : {}),
-            ...(options.cronExpr ? { cronExpr: options.cronExpr } : {}),
-            ...(options.tz ? { tz: options.tz } : {}),
-        })
-        : null;
+    const hasScheduleUpdate = options.at !== undefined
+        || options.everyMs !== undefined
+        || options.cronExpr !== undefined
+        || options.tz !== undefined;
     await context.store.updateJob(options.jobId, (current) => {
         const updatedDelivery = {
             connectorId: options.connectorId ?? current.delivery.connectorId,
@@ -209,14 +198,37 @@ export async function runCronUpdateCommand(options) {
             connectorId: updatedDelivery.connectorId,
             routeId: updatedDelivery.routeId,
         });
-        const schedule = nextSchedule ?? current.schedule;
-        const nextRunAtMs = nextSchedule
+        let schedule = current.schedule;
+        if (hasScheduleUpdate) {
+            const hasExplicitScheduleVariant = options.at !== undefined
+                || options.everyMs !== undefined
+                || options.cronExpr !== undefined;
+            if (hasExplicitScheduleVariant) {
+                schedule = parseSchedule({
+                    ...(options.at ? { at: options.at } : {}),
+                    ...(options.everyMs !== undefined ? { everyMs: options.everyMs } : {}),
+                    ...(options.cronExpr ? { cronExpr: options.cronExpr } : {}),
+                    ...(options.tz ? { tz: options.tz } : {}),
+                });
+            }
+            else if (options.tz !== undefined) {
+                if (current.schedule.kind !== "cron") {
+                    throw new Error("--tz can only be updated for cron schedules or together with --cron");
+                }
+                schedule = {
+                    kind: "cron",
+                    expr: current.schedule.expr,
+                    ...(options.tz ? { tz: options.tz } : {}),
+                };
+            }
+        }
+        const nextRunAtMs = hasScheduleUpdate
             ? computeInitialNextRunAtMs(schedule, now)
             : current.state.nextRunAtMs;
         const nextState = {
             ...current.state,
         };
-        if (nextSchedule) {
+        if (hasScheduleUpdate) {
             if (nextRunAtMs === undefined) {
                 delete nextState.nextRunAtMs;
             }
@@ -224,7 +236,6 @@ export async function runCronUpdateCommand(options) {
                 nextState.nextRunAtMs = nextRunAtMs;
             }
         }
-        const parsedSessionPolicy = parseSessionPolicy(options.sessionPolicy);
         const nextJob = {
             ...current,
             name: options.name ?? current.name,
@@ -234,13 +245,6 @@ export async function runCronUpdateCommand(options) {
             updatedAtMs: now,
             state: nextState,
         };
-        const nextSessionPolicy = parsedSessionPolicy ?? current.sessionPolicy;
-        if (nextSessionPolicy !== undefined) {
-            nextJob.sessionPolicy = nextSessionPolicy;
-        }
-        else {
-            delete nextJob.sessionPolicy;
-        }
         return nextJob;
     });
     console.log(`Updated cron job ${options.jobId}`);

package/dist/src/cli/program.js

@@ -137,7 +137,6 @@ export function buildProgram() {
         .requiredOption("--route <id>", "Route ID")
         .requiredOption("--channel <id>", "Delivery channel/chat ID")
         .option("--thread <id>", "Delivery thread ID")
-        .option("--session-policy <policy>", "Session policy: stateless|shared-session", "stateless")
         .option("--at <iso>", "Run once at ISO timestamp")
         .option("--every-ms <ms>", "Run at fixed interval in milliseconds")
         .option("--cron <expr>", "Cron expression")
@@ -152,7 +151,6 @@ export function buildProgram() {
             routeId: opts.route,
             channelId: opts.channel,
             ...(typeof opts.thread === "string" ? { threadId: opts.thread } : {}),
-            sessionPolicy: opts.sessionPolicy,
             ...(typeof opts.at === "string" ? { at: opts.at } : {}),
             ...(parsedEveryMs !== null && Number.isFinite(parsedEveryMs) ? { everyMs: parsedEveryMs } : {}),
             ...(typeof opts.cron === "string" ? { cronExpr: opts.cron } : {}),
@@ -206,7 +204,6 @@ export function buildProgram() {
         .option("--channel <id>", "Delivery channel/chat ID")
         .option("--thread <id>", "Delivery thread ID")
         .option("--clear-thread", "Unset delivery thread", false)
-        .option("--session-policy <policy>", "Session policy: stateless|shared-session")
         .option("--at <iso>", "Run once at ISO timestamp")
         .option("--every-ms <ms>", "Run at fixed interval in milliseconds")
         .option("--cron <expr>", "Cron expression")
@@ -223,9 +220,6 @@ export function buildProgram() {
             ...(typeof opts.channel === "string" ? { channelId: opts.channel } : {}),
             ...(typeof opts.thread === "string" ? { threadId: opts.thread } : {}),
             clearThread: Boolean(opts.clearThread),
-            ...(typeof opts.sessionPolicy === "string"
-                ? { sessionPolicy: opts.sessionPolicy }
-                : {}),
             ...(typeof opts.at === "string" ? { at: opts.at } : {}),
             ...(parsedEveryMs !== null && Number.isFinite(parsedEveryMs) ? { everyMs: parsedEveryMs } : {}),
             ...(typeof opts.cron === "string" ? { cronExpr: opts.cron } : {}),

package/dist/src/core/types.js

@@ -1 +1,3 @@
 export const BUILTIN_HOST_SANDBOX_ID = "host.builtin";
+export const OUTBOUND_MESSAGE_KIND_METADATA_KEY = "dobby_message_kind";
+export const OUTBOUND_MESSAGE_KIND_PROGRESS = "progress";

package/dist/src/cron/config.js

@@ -7,7 +7,7 @@ const rawCronConfigSchema = z.object({
     storeFile: z.string().min(1).optional(),
     runLogFile: z.string().min(1).optional(),
     pollIntervalMs: z.number().int().positive().default(10_000),
-    maxConcurrentRuns: z.number().int().positive().default(1),
+    maxConcurrentRuns: z.number().int().positive().default(2),
     runMissedOnStartup: z.boolean().default(true),
     jobTimeoutMs: z.number().int().positive().default(10 * 60 * 1000),
 });
@@ -45,7 +45,7 @@ function defaultCronConfigPayload() {
         storeFile: "./data/state/cron-jobs.json",
         runLogFile: "./data/state/cron-runs.jsonl",
         pollIntervalMs: 10_000,
-        maxConcurrentRuns: 1,
+        maxConcurrentRuns: 2,
         runMissedOnStartup: true,
         jobTimeoutMs: 10 * 60 * 1000,
     };