@pasko70/pibo 1.1.0 → 1.3.0

package/dist/core/system-prompt-template.js

@@ -1,16 +1,16 @@
-const AVAILABLE_TOOLS_MARKER = "{{availableTools}}";
-const GUIDELINES_MARKER = "{{guidelines}}";
-function hasTemplateMarkers(systemPrompt) {
-    return systemPrompt.includes(AVAILABLE_TOOLS_MARKER) || systemPrompt.includes(GUIDELINES_MARKER);
+export const PIBO_AVAILABLE_TOOLS_MARKER = "{{availableTools}}";
+export const PIBO_GUIDELINES_MARKER = "{{guidelines}}";
+export function hasPiboSystemPromptTemplateMarkers(systemPrompt) {
+    return systemPrompt.includes(PIBO_AVAILABLE_TOOLS_MARKER) || systemPrompt.includes(PIBO_GUIDELINES_MARKER);
 }
-function buildAvailableTools(options) {
+export function buildPiboAvailableTools(options) {
     const tools = options.selectedTools || ["read", "bash", "edit", "write"];
     const visibleTools = tools.filter((name) => !!options.toolSnippets?.[name]);
     if (visibleTools.length === 0)
         return "(none)";
     return visibleTools.map((name) => `- ${name}: ${options.toolSnippets[name]}`).join("\n");
 }
-function buildGuidelines(options) {
+export function buildPiboGuidelines(options) {
     const tools = options.selectedTools || ["read", "bash", "edit", "write"];
     const guidelinesList = [];
     const guidelinesSet = new Set();
@@ -40,11 +40,11 @@ function buildGuidelines(options) {
     return guidelinesList.map((guideline) => `- ${guideline}`).join("\n");
 }
 export function renderPiboSystemPromptTemplate(systemPrompt, options) {
-    if (!hasTemplateMarkers(systemPrompt))
+    if (!hasPiboSystemPromptTemplateMarkers(systemPrompt))
         return systemPrompt;
     return systemPrompt
-        .replaceAll(AVAILABLE_TOOLS_MARKER, buildAvailableTools(options))
-        .replaceAll(GUIDELINES_MARKER, buildGuidelines(options));
+        .replaceAll(PIBO_AVAILABLE_TOOLS_MARKER, buildPiboAvailableTools(options))
+        .replaceAll(PIBO_GUIDELINES_MARKER, buildPiboGuidelines(options));
 }
 export function createPiboSystemPromptTemplateExtension() {
     return (pi) => {

package/dist/core/telemetry-staleness.js

@@ -0,0 +1,128 @@
+export const DEFAULT_TELEMETRY_STALE_THRESHOLD_MS = 5 * 60 * 1000;
+export const MIN_TELEMETRY_STALE_THRESHOLD_MS = 1_000;
+export const MAX_TELEMETRY_STALE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+export function sanitizeTelemetryStaleThresholdSettings(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return {};
+    const raw = value;
+    const settings = {};
+    const defaultThresholdMs = sanitizeTelemetryStaleThresholdMs(raw.defaultThresholdMs);
+    if (defaultThresholdMs !== undefined)
+        settings.defaultThresholdMs = defaultThresholdMs;
+    const providers = sanitizeThresholdMap(raw.providers);
+    if (Object.keys(providers).length > 0)
+        settings.providers = providers;
+    const profiles = sanitizeThresholdMap(raw.profiles);
+    if (Object.keys(profiles).length > 0)
+        settings.profiles = profiles;
+    return settings;
+}
+export function resolveTelemetryStaleThreshold(input = {}) {
+    const override = sanitizeTelemetryStaleThresholdMs(input.overrideThresholdMs);
+    if (override !== undefined)
+        return { thresholdMs: override, source: "override" };
+    const settings = sanitizeTelemetryStaleThresholdSettings(input.settings);
+    const profileKey = lookupKey(settings.profiles, input.profile);
+    if (profileKey)
+        return { thresholdMs: settings.profiles[profileKey], source: "profile", key: profileKey };
+    const providerKey = lookupKey(settings.providers, input.provider);
+    if (providerKey)
+        return { thresholdMs: settings.providers[providerKey], source: "provider", key: providerKey };
+    return {
+        thresholdMs: settings.defaultThresholdMs ?? DEFAULT_TELEMETRY_STALE_THRESHOLD_MS,
+        source: "default",
+    };
+}
+export class TelemetryStaleDetector {
+    store;
+    settings;
+    constructor(store, settings = {}) {
+        this.store = store;
+        this.settings = settings;
+    }
+    listStaleWork(options = {}) {
+        const candidates = this.store.listStaleWork({
+            limit: 200,
+            now: options.now,
+            thresholdMs: 0,
+        });
+        const limit = normalizeLimit(options.limit);
+        const rows = [];
+        for (const item of candidates) {
+            const timeline = this.store.getTurnTimeline(item.turnId);
+            if (!timeline || timeline.turn.status !== "queued" && timeline.turn.status !== "running")
+                continue;
+            const phase = item.phaseId ? timeline.phases.find((candidate) => candidate.phaseId === item.phaseId) : undefined;
+            const providerRequest = providerForStaleItem(item, timeline.providerRequests);
+            const profile = typeof timeline.turn.metadata.profile === "string" ? timeline.turn.metadata.profile : undefined;
+            const threshold = resolveTelemetryStaleThreshold({
+                provider: providerRequest?.provider,
+                profile,
+                settings: options.settings ?? this.settings,
+                overrideThresholdMs: options.thresholdMs,
+            });
+            if (item.staleForMs < threshold.thresholdMs)
+                continue;
+            rows.push({
+                ...item,
+                phase: phase?.name ?? item.phase,
+                activePhase: phase?.name ?? item.phase,
+                lastProgressAt: item.lastProgressAt ?? phase?.lastProgressAt ?? phase?.startedAt,
+                thresholdMs: threshold.thresholdMs,
+                appliedThresholdMs: threshold.thresholdMs,
+                thresholdSource: threshold.source,
+                thresholdKey: threshold.key,
+                provider: providerRequest?.provider,
+                model: providerRequest?.model,
+                profile,
+                active: true,
+                nextCommands: item.nextCommands,
+            });
+            if (rows.length >= limit)
+                break;
+        }
+        return rows;
+    }
+}
+function providerForStaleItem(item, providers) {
+    if (item.phaseId) {
+        const linked = providers.find((provider) => provider.phaseId === item.phaseId);
+        if (linked)
+            return linked;
+    }
+    return providers[0];
+}
+function sanitizeThresholdMap(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return {};
+    const output = {};
+    for (const [rawKey, rawThreshold] of Object.entries(value)) {
+        const key = rawKey.trim().toLowerCase();
+        if (!key)
+            continue;
+        const threshold = sanitizeTelemetryStaleThresholdMs(rawThreshold);
+        if (threshold === undefined)
+            continue;
+        output[key] = threshold;
+    }
+    return output;
+}
+function sanitizeTelemetryStaleThresholdMs(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return undefined;
+    const threshold = Math.floor(value);
+    if (threshold < MIN_TELEMETRY_STALE_THRESHOLD_MS || threshold > MAX_TELEMETRY_STALE_THRESHOLD_MS)
+        return undefined;
+    return threshold;
+}
+function lookupKey(map, value) {
+    if (!map || !value)
+        return undefined;
+    const key = value.trim().toLowerCase();
+    return Object.prototype.hasOwnProperty.call(map, key) ? key : undefined;
+}
+function normalizeLimit(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return 20;
+    return Math.max(1, Math.min(200, Math.floor(value)));
+}

package/dist/core/test-output-compaction.js

@@ -0,0 +1,145 @@
+export const PIBO_BASH_OUTPUT_COMPACTION_DETAILS_KEY = "piboBashOutputCompaction";
+const MAX_ERROR_CONTEXT_LINES = 120;
+const ERROR_CONTEXT_RADIUS = 2;
+const MIN_SUCCESS_LINES_TO_COMPACT = 12;
+const COMPACTED_MARKER = "[Pibo compacted validation output]";
+const VALIDATION_COMMAND_PATTERN = /(?:^|[\s;&|()])(?:(?:npm|pnpm|yarn|bun)\s+run\s+[^\s;&|()]*?(?:test|typecheck|check|lint|build)[^\s;&|()]*|(?:npm|pnpm|yarn|bun)\s+(?:test|t)\b|(?:npx\s+)?(?:vitest|jest|mocha|ava|playwright|cypress|pytest|ruff|eslint|tsc|tsc\s+--noEmit|node\s+--test|go\s+test|cargo\s+test|dotnet\s+test)\b)/i;
+const ERROR_LINE_PATTERN = /(?:\b(?:FAIL|FAILED|Failing|failure|failed|ERROR|Error|error|ERR!|Exception|Traceback|AssertionError|assert|expected|received|not ok|timed out|Command exited with code)\b|[✕×✖])/;
+const BENIGN_SUCCESS_LINE_PATTERN = /(?:^\s*(?:✔|✓|PASS\b)|\b(?:PASS|passed|success|successful|ok|done|completed)\b)/i;
+export function compactValidationToolResultForContext(context) {
+    const toolName = typeof context.toolCall?.name === "string" ? context.toolCall.name : undefined;
+    if (toolName !== "bash")
+        return undefined;
+    const command = commandFromArgs(context.args);
+    if (!command || !isLikelyValidationCommand(command))
+        return undefined;
+    const output = textFromContent(context.result.content);
+    if (!output || output.includes(COMPACTED_MARKER))
+        return undefined;
+    const compaction = compactValidationOutput({ command, output, isError: context.isError });
+    if (!compaction)
+        return undefined;
+    return {
+        content: [{ type: "text", text: compaction.text }],
+        details: mergeCompactionDetails(context.result.details, compaction.details),
+        isError: context.isError,
+        terminate: context.result.terminate,
+    };
+}
+export function compactValidationOutput(input) {
+    const normalizedOutput = input.output.replace(/\r\n/g, "\n").trimEnd();
+    const lines = normalizedOutput.length ? normalizedOutput.split("\n") : [];
+    if (!input.isError && lines.length < MIN_SUCCESS_LINES_TO_COMPACT)
+        return undefined;
+    const interestingRanges = collectInterestingRanges(lines);
+    const interestingLines = rangesToLines(lines, interestingRanges, MAX_ERROR_CONTEXT_LINES);
+    const displayedBody = input.isError
+        ? (interestingLines.length ? interestingLines : tailLines(lines, MAX_ERROR_CONTEXT_LINES))
+        : [];
+    const statusLine = input.isError
+        ? "Command failed. Showing error-looking lines only."
+        : "Command succeeded. Test output hidden by default.";
+    const omittedLines = Math.max(0, lines.length - displayedBody.length);
+    const header = [
+        COMPACTED_MARKER,
+        statusLine,
+        `Original output: ${lines.length} line${lines.length === 1 ? "" : "s"}, ${normalizedOutput.length} chars.`,
+        omittedLines > 0 ? `Hidden: ${omittedLines} line${omittedLines === 1 ? "" : "s"}. Full output omitted from model context.` : undefined,
+    ].filter((line) => Boolean(line));
+    const text = displayedBody.length
+        ? `${header.join("\n")}\n\n${displayedBody.join("\n")}`
+        : header.join("\n");
+    const fullOutputPath = extractFullOutputPath(normalizedOutput);
+    const details = {
+        kind: "validation-output",
+        command: input.command,
+        isError: input.isError,
+        originalLines: lines.length,
+        originalChars: normalizedOutput.length,
+        displayedLines: displayedBody.length,
+        omittedLines,
+        fullOutputPath,
+    };
+    return { text, details };
+}
+function commandFromArgs(args) {
+    if (!isRecord(args))
+        return undefined;
+    const command = args.command;
+    return typeof command === "string" && command.trim() ? command : undefined;
+}
+function isLikelyValidationCommand(command) {
+    return VALIDATION_COMMAND_PATTERN.test(command);
+}
+function textFromContent(content) {
+    if (!Array.isArray(content) || content.length === 0)
+        return undefined;
+    const parts = [];
+    for (const part of content) {
+        if (!part || part.type !== "text")
+            return undefined;
+        parts.push(part.text);
+    }
+    return parts.join("");
+}
+function collectInterestingRanges(lines) {
+    const ranges = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        if (BENIGN_SUCCESS_LINE_PATTERN.test(lines[index]))
+            continue;
+        if (!ERROR_LINE_PATTERN.test(lines[index]))
+            continue;
+        ranges.push([
+            Math.max(0, index - ERROR_CONTEXT_RADIUS),
+            Math.min(lines.length - 1, index + ERROR_CONTEXT_RADIUS),
+        ]);
+    }
+    return mergeRanges(ranges);
+}
+function mergeRanges(ranges) {
+    const merged = [];
+    for (const [start, end] of ranges.sort((left, right) => left[0] - right[0])) {
+        const previous = merged.at(-1);
+        if (!previous || start > previous[1] + 1) {
+            merged.push([start, end]);
+        }
+        else {
+            previous[1] = Math.max(previous[1], end);
+        }
+    }
+    return merged;
+}
+function rangesToLines(lines, ranges, maxLines) {
+    const output = [];
+    for (const [rangeIndex, [start, end]] of ranges.entries()) {
+        if (output.length >= maxLines)
+            break;
+        if (rangeIndex > 0)
+            output.push("...");
+        for (let index = start; index <= end && output.length < maxLines; index += 1) {
+            output.push(lines[index]);
+        }
+    }
+    if (ranges.length > 0 && output.length >= maxLines)
+        output.push(`... (${ranges.length} error section${ranges.length === 1 ? "" : "s"} truncated)`);
+    return output;
+}
+function tailLines(lines, maxLines) {
+    return lines.slice(Math.max(0, lines.length - maxLines));
+}
+function mergeCompactionDetails(originalDetails, compaction) {
+    if (isRecord(originalDetails)) {
+        return { ...originalDetails, [PIBO_BASH_OUTPUT_COMPACTION_DETAILS_KEY]: compaction };
+    }
+    return {
+        [PIBO_BASH_OUTPUT_COMPACTION_DETAILS_KEY]: compaction,
+        ...(originalDetails === undefined ? {} : { originalDetails }),
+    };
+}
+function extractFullOutputPath(output) {
+    const match = output.match(/Full output:\s*([^\]\n]+)/);
+    return match?.[1]?.trim();
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/core/user-settings.js

@@ -0,0 +1,73 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { piboHomePath } from "./pibo-home.js";
+import { sanitizeTelemetryStaleThresholdSettings } from "./telemetry-staleness.js";
+export const DEFAULT_USER_TIMEZONE = "UTC";
+export const DEFAULT_WEB_ANNOTATIONS_TOGGLE_SHORTCUT = "Alt+Shift+A";
+export const DEFAULT_PIBO_USER_SETTINGS_PATH = "user-settings.json";
+export function loadPiboUserSettings() {
+    return sanitizeUserSettings(readState().settings);
+}
+export function updatePiboUserSettings(patch) {
+    const state = readState();
+    const next = sanitizeUserSettings({ ...(state.settings ?? {}), ...patch });
+    state.settings = next;
+    writeState(state);
+    return next;
+}
+export function sanitizeShortcutSettings(value) {
+    const raw = value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+    return { webAnnotationsToggle: sanitizeShortcut(raw.webAnnotationsToggle) ?? DEFAULT_WEB_ANNOTATIONS_TOGGLE_SHORTCUT };
+}
+export function sanitizeShortcut(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const shortcut = value.replace(/[\u0000-\u001f\u007f]/g, "").trim();
+    return shortcut && shortcut.length <= 80 ? shortcut : undefined;
+}
+export function sanitizeTimezone(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const timezone = value.trim();
+    if (!timezone)
+        return undefined;
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone: timezone });
+        return timezone;
+    }
+    catch {
+        return undefined;
+    }
+}
+function sanitizeUserSettings(value) {
+    const raw = value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+    return {
+        timezone: sanitizeTimezone(raw.timezone) ?? DEFAULT_USER_TIMEZONE,
+        shortcuts: sanitizeShortcutSettings(raw.shortcuts),
+        telemetryStaleThresholds: sanitizeTelemetryStaleThresholdSettings(raw.telemetryStaleThresholds),
+    };
+}
+function readState() {
+    const path = piboHomePath(DEFAULT_PIBO_USER_SETTINGS_PATH);
+    if (!existsSync(path))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        const raw = parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+        return { settings: sanitizeUserSettings(raw.settings) };
+    }
+    catch {
+        return {};
+    }
+}
+function writeState(state) {
+    const path = piboHomePath(DEFAULT_PIBO_USER_SETTINGS_PATH);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(state, null, 2)}\n`);
+}

package/dist/cron/channel.js

@@ -0,0 +1,28 @@
+import { PiboCronService } from "./service.js";
+import { createDefaultPiboCronStore } from "./store.js";
+let currentCronService;
+export function getPiboCronService() {
+    return currentCronService;
+}
+export function createPiboCronChannel(options = {}) {
+    return {
+        name: "pibo.cron",
+        kind: "custom",
+        description: "Runs scheduled Pibo agent jobs.",
+        auth: { mode: "required" },
+        start(context) {
+            if (currentCronService)
+                return;
+            currentCronService = new PiboCronService({
+                ...options,
+                context,
+                store: createDefaultPiboCronStore({ path: options.cronStorePath }),
+            });
+            currentCronService.start();
+        },
+        stop() {
+            currentCronService?.stop();
+            currentCronService = undefined;
+        },
+    };
+}

package/dist/cron/cli.js

@@ -0,0 +1,230 @@
+import { Command } from "commander";
+import { parseFriendlySchedule } from "./schedule.js";
+import { createDefaultPiboCronStore } from "./store.js";
+function printDiscovery() {
+    console.log(`pibo cron
+
+Manage scheduled Pibo agent jobs.
+
+Commands:
+  status    Show scheduler store status
+  list      List cron jobs
+  add       Create a cron job
+  edit      Update a cron job
+  pause     Disable a cron job
+  resume    Enable a cron job and recompute next run
+  remove    Delete a cron job
+  runs      List cron runs
+
+Next: pibo cron add --help
+      pibo cron edit --help`);
+}
+function printJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+function targetFromOptions(options) {
+    if (options.room)
+        return { kind: "room", roomId: options.room };
+    if (options.defaultChat)
+        return { kind: "default-chat" };
+    throw new Error("Choose a target: --room <roomId> or --default-chat");
+}
+function maybeTargetFromOptions(options) {
+    if (!options.room && !options.defaultChat)
+        return undefined;
+    return targetFromOptions(options);
+}
+function hasScheduleOptions(options, positionalCron) {
+    return Boolean(positionalCron ||
+        typeof options.in === "string" ||
+        typeof options.at === "string" ||
+        typeof options.every === "string" ||
+        typeof options.daily === "string" ||
+        typeof options.weekly === "string" ||
+        typeof options.monthly === "string" ||
+        typeof options.monthly === "number" ||
+        typeof options.cron === "string");
+}
+function scheduleFromOptions(options, positionalCron) {
+    if (typeof options.in === "string")
+        return parseFriendlySchedule({ kind: "in", value: options.in });
+    if (typeof options.at === "string")
+        return parseFriendlySchedule({ kind: "at", value: options.at, tz: typeof options.tz === "string" ? options.tz : undefined });
+    if (typeof options.every === "string")
+        return parseFriendlySchedule({ kind: "every", value: options.every });
+    if (typeof options.daily === "string")
+        return parseFriendlySchedule({ kind: "daily", time: options.daily, tz: typeof options.tz === "string" ? options.tz : undefined });
+    if (typeof options.weekly === "string") {
+        const time = typeof options.time === "string" ? options.time : undefined;
+        if (!time)
+            throw new Error("--weekly requires --time HH:MM");
+        return parseFriendlySchedule({ kind: "weekly", weekdays: options.weekly, time, tz: typeof options.tz === "string" ? options.tz : undefined });
+    }
+    if (typeof options.monthly === "string" || typeof options.monthly === "number") {
+        const time = typeof options.time === "string" ? options.time : undefined;
+        if (!time)
+            throw new Error("--monthly requires --time HH:MM");
+        return parseFriendlySchedule({ kind: "monthly", dayOfMonth: Number(options.monthly), time, tz: typeof options.tz === "string" ? options.tz : undefined });
+    }
+    if (typeof options.cron === "string")
+        return parseFriendlySchedule({ kind: "cron", expr: options.cron, tz: typeof options.tz === "string" ? options.tz : undefined });
+    if (positionalCron)
+        return parseFriendlySchedule({ kind: "cron", expr: positionalCron, tz: typeof options.tz === "string" ? options.tz : undefined });
+    throw new Error("Choose a schedule: --in, --at, --every, --daily, --weekly, --monthly, --cron, or pass a quoted cron expression");
+}
+export async function runCronCli(argv = process.argv) {
+    if (argv.length <= 2 || argv[2] === "--help" || argv[2] === "-h") {
+        printDiscovery();
+        return;
+    }
+    const program = new Command();
+    program.name("pibo cron").description("Manage scheduled Pibo jobs").helpOption("-h, --help");
+    program.option("--store <path>", "Cron store path");
+    program.command("status").description("Show cron store status").option("--json", "Print JSON").action((options) => {
+        const store = createDefaultPiboCronStore({ path: program.opts().store });
+        const status = store.status();
+        if (options.json)
+            printJson(status);
+        else {
+            console.log(`jobs\t${status.jobs}`);
+            console.log(`running\t${status.running}`);
+            console.log(`nextRunAt\t${status.nextRunAt ?? "-"}`);
+        }
+        store.close();
+    });
+    program.command("list").description("List cron jobs").option("--all", "Include disabled jobs").option("--json", "Print JSON").action((options) => {
+        const store = createDefaultPiboCronStore({ path: program.opts().store });
+        const jobs = store.listJobs({ includeDisabled: options.all });
+        if (options.json)
+            printJson(jobs);
+        else
+            for (const job of jobs)
+                console.log(`${job.id}\t${job.enabled ? "enabled" : "disabled"}\t${job.state.nextRunAt ?? "-"}\t${job.name}`);
+        store.close();
+    });
+    program.command("add")
+        .description("Create a cron job")
+        .argument("[cronExpr...]", "Raw 5-field cron expression, e.g. \"0 8 * * *\"")
+        .option("--room <roomId>", "Target room")
+        .option("--default-chat", "Target the shared default chat")
+        .option("--agent <profile>", "Agent/profile", "base")
+        .option("--name <name>", "Job name")
+        .requiredOption("--prompt <text>", "Prompt/task")
+        .option("--in <duration>", "Run once after duration, e.g. 20m")
+        .option("--at <iso>", "Run once at ISO timestamp")
+        .option("--every <duration>", "Run every duration, e.g. 2h")
+        .option("--daily <HH:MM>", "Run daily at time")
+        .option("--weekly <days>", "Run weekly on comma-separated days")
+        .option("--monthly <day>", "Run monthly on day of month")
+        .option("--time <HH:MM>", "Time for weekly/monthly")
+        .option("--cron <expr>", "Raw 5-field cron expression")
+        .option("--tz <timezone>", "Timezone for wall-clock schedules")
+        .option("--disabled", "Create disabled")
+        .option("--delete-after-run", "Delete successful one-shot job")
+        .option("--json", "Print JSON")
+        .action((cronExprParts, options) => {
+        const store = createDefaultPiboCronStore({ path: program.opts().store });
+        const positionalCron = Array.isArray(cronExprParts) && cronExprParts.length ? cronExprParts.join(" ") : undefined;
+        const normalized = scheduleFromOptions(options, positionalCron);
+        const job = store.createJob({
+            name: options.name,
+            enabled: options.disabled ? false : true,
+            target: targetFromOptions(options),
+            profile: options.agent,
+            prompt: options.prompt,
+            schedule: normalized.schedule,
+            scheduleUi: normalized.scheduleUi,
+            deleteAfterRun: options.deleteAfterRun === true,
+        });
+        if (options.json)
+            printJson(job);
+        else
+            console.log(`${job.id}\t${job.state.nextRunAt ?? "-"}\t${job.name}`);
+        store.close();
+    });
+    program.command("edit")
+        .description("Update a cron job")
+        .argument("<id>", "Cron job id")
+        .argument("[cronExpr...]", "Raw 5-field cron expression, e.g. \"0 8 * * *\"")
+        .option("--room <roomId>", "Target room")
+        .option("--default-chat", "Target the shared default chat")
+        .option("--agent <profile>", "Agent/profile")
+        .option("--name <name>", "Job name")
+        .option("--description <text>", "Job description")
+        .option("--prompt <text>", "Prompt/task")
+        .option("--in <duration>", "Run once after duration, e.g. 20m")
+        .option("--at <iso>", "Run once at ISO timestamp")
+        .option("--every <duration>", "Run every duration, e.g. 2h")
+        .option("--daily <HH:MM>", "Run daily at time")
+        .option("--weekly <days>", "Run weekly on comma-separated days")
+        .option("--monthly <day>", "Run monthly on day of month")
+        .option("--time <HH:MM>", "Time for weekly/monthly")
+        .option("--cron <expr>", "Raw 5-field cron expression")
+        .option("--tz <timezone>", "Timezone for wall-clock schedules")
+        .option("--enabled", "Enable the job")
+        .option("--disabled", "Disable the job")
+        .option("--delete-after-run", "Delete successful one-shot job")
+        .option("--keep-after-run", "Keep job after successful one-shot run")
+        .option("--json", "Print JSON")
+        .action((id, cronExprParts, options) => {
+        const store = createDefaultPiboCronStore({ path: program.opts().store });
+        const positionalCron = Array.isArray(cronExprParts) && cronExprParts.length ? cronExprParts.join(" ") : undefined;
+        const normalized = hasScheduleOptions(options, positionalCron) ? scheduleFromOptions(options, positionalCron) : undefined;
+        const target = maybeTargetFromOptions(options);
+        const patch = {
+            ...(options.name !== undefined ? { name: options.name } : {}),
+            ...(options.description !== undefined ? { description: options.description } : {}),
+            ...(options.agent !== undefined ? { profile: options.agent } : {}),
+            ...(options.prompt !== undefined ? { prompt: options.prompt } : {}),
+            ...(target ? { target } : {}),
+            ...(normalized ? { schedule: normalized.schedule, scheduleUi: normalized.scheduleUi } : {}),
+            ...(options.enabled === true ? { enabled: true } : {}),
+            ...(options.disabled === true ? { enabled: false } : {}),
+            ...(options.deleteAfterRun === true ? { deleteAfterRun: true } : {}),
+            ...(options.keepAfterRun === true ? { deleteAfterRun: false } : {}),
+        };
+        if (Object.keys(patch).length === 0)
+            throw new Error("No cron job update fields provided");
+        const job = store.updateJob(id, patch);
+        if (!job)
+            throw new Error("Cron job not found");
+        if (options.json)
+            printJson(job);
+        else
+            console.log(`${job.id}\t${job.enabled ? "enabled" : "disabled"}\t${job.state.nextRunAt ?? "-"}\t${job.name}`);
+        store.close();
+    });
+    for (const [name, enabled] of [["pause", false], ["resume", true]]) {
+        program.command(name).argument("<id>").description(enabled ? "Enable a cron job" : "Disable a cron job").option("--json", "Print JSON").action((id, options) => {
+            const store = createDefaultPiboCronStore({ path: program.opts().store });
+            const job = store.updateJob(id, { enabled });
+            if (!job)
+                throw new Error("Cron job not found");
+            if (options.json)
+                printJson(job);
+            else
+                console.log(`${job.id}\t${job.enabled ? "enabled" : "disabled"}\t${job.state.nextRunAt ?? "-"}`);
+            store.close();
+        });
+    }
+    program.command("remove").argument("<id>").description("Delete a cron job").option("--json", "Print JSON").action((id, options) => {
+        const store = createDefaultPiboCronStore({ path: program.opts().store });
+        const removed = store.removeJob(id);
+        if (options.json)
+            printJson({ removed });
+        else
+            console.log(removed ? "removed" : "not found");
+        store.close();
+    });
+    program.command("runs").description("List cron runs").option("--job <id>", "Filter by job").option("--json", "Print JSON").action((options) => {
+        const store = createDefaultPiboCronStore({ path: program.opts().store });
+        const runs = store.listRuns({ jobId: options.job });
+        if (options.json)
+            printJson(runs);
+        else
+            for (const run of runs)
+                console.log(`${run.id}\t${run.status}\t${run.createdAt}\t${run.piboSessionId ?? "-"}`);
+        store.close();
+    });
+    await program.parseAsync(argv);
+}

package/dist/cron/plugin.js

@@ -0,0 +1,11 @@
+import { definePiboPlugin } from "../plugins/registry.js";
+import { createPiboCronChannel } from "./channel.js";
+export function createPiboCronPlugin(options = {}) {
+    return definePiboPlugin({
+        id: "pibo.cron",
+        name: "Pibo Cron",
+        register(api) {
+            api.registerChannel(createPiboCronChannel(options));
+        },
+    });
+}