@indigoai-us/hq-cli 5.345.191 → 5.345.194

package/dist/commands/bot-jobs.js

@@ -10,13 +10,16 @@
  * The schedule lives with the bot: its jobs sit in the bot's own folder
  * (lib/bot/local-jobs.ts) and the bot's inbox loop fires them while it runs
  * (see lib/bot/job-run.ts). Nothing here writes a crontab, a launchd plist, or
- * a systemd unit — by rule. Schedules are still written in the EventBridge form
- * and held to the same limits, so a job reads the same wherever it runs.
+ * a systemd unit — by rule. A schedule is stored as a six-field
+ * `cron(m h dom mon dow year)` string (Sunday = 1, `?` in one day field), the
+ * same string format hosted agent jobs use, and lib/bot/local-jobs.ts reads it
+ * back when it checks what is due.
  */
 import chalk from "chalk";
 import { localJobsClient } from "../lib/bot/local-jobs.js";
 import { BotApiError } from "../lib/bot/api.js";
-import { effectiveBotKind } from "../lib/bot/config.js";
+import { effectiveBotKind, HQ_FLEET_RUNTIME_ENGINE_ID } from "../lib/bot/config.js";
+import { fleetCronOps, fleetOwnerOrigin, fleetScheduleFromLegacy } from "../lib/bot/fleet-cron.js";
 import { isQuietJobContext, JOB_RUN_OPTIONS_CONTEXT_KEY } from "../lib/bot/job-run.js";
 import { BOT_JOB_QUIET_OPTION_FLAG, botJobQuietOptionEnabled } from "../lib/bot/job-quiet-flag.js";
 import { runScheduleParse } from "./core-jobs-schedule.js";
@@ -43,9 +46,11 @@ export function machineTimezone() {
     }
 }
 /**
- * Standard 5-field cron → the EventBridge form the cloud stores.
+ * Standard 5-field cron → the six-field `cron(...)` string a job is stored as.
  *
- * EventBridge cron has SIX fields (a trailing year), numbers its days of week
+ * The stored form (the six-field cron syntax hosted agent jobs also use, so
+ * local and hosted jobs share one format; the function keeps its historical
+ * name) has SIX fields (a trailing year), numbers its days of week
  * 1–7 with SUNDAY = 1 (standard cron uses 0–6 with SUNDAY = 0), and refuses
  * `*` in BOTH the day-of-month and day-of-week fields — exactly one must be
  * `?`. An expression that is already `cron(...)` or `rate(...)` is passed
@@ -54,18 +59,19 @@ export function machineTimezone() {
 export function toEventBridgeCron(expr) {
     const trimmed = expr.trim();
     // An explicit cron(...) / rate(...) is the caller saying "this is already the
-    // cloud's own syntax" — passed through untranslated, on purpose.
+    // stored syntax" — passed through untranslated, on purpose.
     if (/^(cron|rate)\s*\(/i.test(trimmed))
         return trimmed;
     const fields = trimmed.split(/\s+/).filter(Boolean);
     if (fields.length === 6) {
-        // Six BARE fields are ambiguous: EventBridge's sixth field is a trailing
-        // year, Quartz's first is leading seconds. Guessing wrong silently moves
-        // every run. Make the caller say which they mean.
-        refuse(`"${trimmed}" has six fields, and I can't tell whether that is an EventBridge expression ` +
-            `(minute hour day-of-month month day-of-week year) or a Quartz one (leading seconds) — ` +
-            `reading it the wrong way would schedule the job at the wrong time. Pass five fields ` +
-            `("0 9 * * 1-5"), or wrap it yourself as cron(...) if it is already an EventBridge expression.`);
+        // Six BARE fields are ambiguous: the stored form's sixth field is a
+        // trailing year, Quartz's first is leading seconds. Guessing wrong
+        // silently moves every run. Make the caller say which they mean.
+        refuse(`"${trimmed}" has six fields, and I can't tell whether the last one is a year ` +
+            `(minute hour day-of-month month day-of-week year, the form bot jobs are stored in) or the ` +
+            `first one is seconds (a Quartz expression) — reading it the wrong way would schedule the job ` +
+            `at the wrong time. Pass five fields ("0 9 * * 1-5"), or wrap it yourself as cron(...) if it ` +
+            `already ends with a year field.`);
     }
     if (fields.length !== 5) {
         refuse(`"${trimmed}" is not a cron expression. A cron expression has five fields: ` +
@@ -87,7 +93,7 @@ export function toEventBridgeCron(expr) {
     return `cron(${minute} ${hour} ${dayOfMonth} ${month} ${dayOfWeek} *)`;
 }
 /**
- * Standard 0–6 (SUN=0, and 7 also SUN) → EventBridge 1–7 (SUN=1).
+ * Standard 0–6 (SUN=0, and 7 also SUN) → the stored form's 1–7 (SUN=1).
  *
  * Mapped per TERM, not per digit. Shifting digits individually turned a range
  * that wraps past Sunday — "6-0" (Sat–Sun), "5-1" (Fri–Mon) — into "7-1" /
@@ -155,7 +161,7 @@ export function recurringIntervalSeconds(expr) {
     const minute = cron[1];
     if (minute === "*" || minute === "?")
         return 60;
-    // EventBridge also writes a step as "start/every" ("0/10" = every 10 minutes
+    // The stored form also writes a step as "start/every" ("0/10" = every 10 minutes
     // from :00), which the rate()-style regex alone rejected as unparseable.
     const step = minute.match(/^(?:\*|\d+|\d+-\d+)\/(\d+)$/);
     if (step) {
@@ -177,7 +183,7 @@ export function recurringIntervalSeconds(expr) {
     }
     return null;
 }
-/** Refuse a schedule the cloud would refuse, with the cloud's own reason. */
+/** Refuse a schedule that fires more often than the recurring floor (the same floor hosted agent jobs use). */
 export function assertScheduleWithinFloor(expr) {
     const interval = recurringIntervalSeconds(expr);
     if (interval === null) {
@@ -212,7 +218,7 @@ export function parseScheduleText(text, opts) {
         ...(parsed.human?.trim() ? { human: parsed.human.trim() } : {}),
     };
 }
-/** The create body the cloud expects, with the client-side limits enforced first. */
+/** The create body for a new job, with the schedule limits enforced first. */
 export function buildCreateJobBody(input) {
     const prompt = input.prompt.trim();
     if (!prompt)
@@ -236,6 +242,79 @@ export function buildCreateJobBody(input) {
         schedule: { kind: "recurring", cron, timezone: input.timezone },
     };
 }
+export function fromEventBridgeCron(expr) {
+    try {
+        return fleetScheduleFromLegacy(expr);
+    }
+    catch (error) {
+        refuse(error instanceof Error ? error.message : String(error));
+    }
+}
+function fleetJobStatus(job) {
+    if (job.enabled === false)
+        return "paused";
+    if (!job.state || job.state === "scheduled")
+        return "active";
+    return job.state;
+}
+function fleetJobSchedule(job, timezone) {
+    const schedule = job.schedule ?? {};
+    if (schedule.kind === "once")
+        return { kind: "once", ...(schedule.run_at ? { at: schedule.run_at } : {}), timezone };
+    if (schedule.kind === "interval" && typeof schedule.minutes === "number") {
+        return { kind: "recurring", cron: `rate(${schedule.minutes} minutes)`, timezone };
+    }
+    const expr = schedule.expr ?? "";
+    try {
+        return { kind: "recurring", cron: toEventBridgeCron(expr), timezone };
+    }
+    catch {
+        return { kind: "recurring", cron: expr, timezone };
+    }
+}
+export function fleetJobRecord(job, timezone) {
+    return {
+        jobId: job.id,
+        prompt: job.prompt?.trim() || job.name || (job.script ? `runs ${job.script}` : ""),
+        status: fleetJobStatus(job),
+        schedule: fleetJobSchedule(job, timezone),
+        ...(job.script ? { script: job.script } : {}),
+        ...(job.created_at ? { createdAt: job.created_at } : {}),
+        ...(job.next_run_at ? { nextRunAt: job.next_run_at } : {}),
+        ...(job.last_run_at ? { lastRunAt: job.last_run_at } : {}),
+        ...(job.last_status ? { lastStatus: job.last_status } : {}),
+        ...(job.repeat?.completed ? { runCount: job.repeat.completed } : {}),
+    };
+}
+export function fleetJobsClient(config, ops, timezone) {
+    return {
+        async listJobs() {
+            return ops.list().map((job) => fleetJobRecord(job, timezone));
+        },
+        async createJob(_agentUid, input) {
+            if (input.schedule.kind !== "recurring") {
+                throw new BotApiError(400, "fleet jobs", "JOB_VALIDATION", "A local bot runs recurring jobs only.");
+            }
+            const schedule = fromEventBridgeCron(input.schedule.cron);
+            const jobs = ops.list();
+            if (jobs.filter((job) => job.enabled !== false).length >= MAX_ACTIVE_JOBS_PER_AGENT) {
+                throw new BotApiError(409, "fleet jobs", "JOB_QUOTA_EXCEEDED", `at most ${MAX_ACTIVE_JOBS_PER_AGENT} jobs`);
+            }
+            const job = ops.create({ prompt: input.prompt, schedule, origin: fleetOwnerOrigin(config.ownerUid, jobs), workdir: config.hqRoot });
+            return fleetJobRecord(job, timezone);
+        },
+        async cancelJob(_agentUid, jobId) {
+            if (!ops.remove(jobId))
+                throw new BotApiError(404, "fleet jobs", "JOB_NOT_FOUND", `Job '${jobId}' not found`);
+        },
+        async rescheduleJob(_agentUid, jobId, schedule) {
+            const job = ops.reschedule(jobId, fromEventBridgeCron(schedule.cron));
+            if (!job)
+                throw new BotApiError(404, "fleet jobs", "JOB_NOT_FOUND", `Job '${jobId}' not found`);
+            return fleetJobRecord(job, timezone);
+        },
+    };
+}
 // ─── Reading jobs back ───────────────────────────────────────────────────────
 /** A schedule in plain words, falling back to the raw expression. */
 export function describeSchedule(job) {
@@ -277,7 +356,7 @@ export function cronInWords(expr) {
             return `on day ${dayOfMonth} of each month at ${at}`;
         return null;
     }
-    // EventBridge days of week: SUNDAY = 1.
+    // Stored-form days of week: SUNDAY = 1.
     if (dayOfWeek === "2-6")
         return `every weekday at ${at}`;
     if (/^\d$/.test(dayOfWeek))
@@ -288,11 +367,16 @@ export function cronInWords(expr) {
     }
     return null;
 }
+export function utcMinute(iso) {
+    const time = Date.parse(iso);
+    const value = Number.isNaN(time) ? iso : new Date(time).toISOString();
+    return value.slice(0, 16).replace("T", " ");
+}
 /** "never run yet" / "succeeded 2026-09-15 09:00 UTC". */
 export function describeLastRun(job) {
     if (!job.lastStatus && !job.lastRunAt)
         return "not run yet";
-    const when = job.lastRunAt ? ` ${job.lastRunAt.slice(0, 16).replace("T", " ")} UTC` : "";
+    const when = job.lastRunAt ? ` ${utcMinute(job.lastRunAt)} UTC` : "";
     return `${job.lastStatus ?? "ran"}${when}`;
 }
 export function formatJobsList(botName, jobs, showQuietOption = false) {
@@ -307,35 +391,23 @@ export function formatJobsList(botName, jobs, showQuietOption = false) {
         lines.push(`    runs ${describeSchedule(job)}`);
         if (showQuietOption && isQuietJobContext(job.context))
             lines.push("    delivery: quiet after successful runs");
-        lines.push(`    next run: ${job.nextRunAt ? `${job.nextRunAt.slice(0, 16).replace("T", " ")} UTC` : "not scheduled yet"}`);
+        lines.push(`    next run: ${job.nextRunAt ? `${utcMinute(job.nextRunAt)} UTC` : "not scheduled yet"}`);
         lines.push(`    last run: ${describeLastRun(job)}`);
     }
     return lines.join("\n");
 }
 // ─── Errors a person can act on ──────────────────────────────────────────────
 /**
- * Turn a jobs-route failure into one plain line.
+ * Turn a jobs failure into one plain line.
  *
- * Personal bots are refused by the cloud today: their JWT carries the owner's
- * `per_…` company claim and the jobs routes require a `cmp_…`, so the fail-closed
- * guard answers 403 `CROSS_AGENT_JOB` (hq-pro-agents jobs/errors.ts
- * `CrossAgentJobError`). That server fix is a separate change; until it lands the
- * refusal must read as "not available yet for this kind of bot", not as a raw 403.
- * Once the server accepts personal bots the refusal simply stops happening — no
- * client change needed.
- *
- * ONLY that exact code is rewritten. Every other 403, and every 404, keeps its
- * real message: masking them would hide a genuinely missing job or a different
- * permission problem behind copy about the wrong thing.
+ * `hq bot jobs` answers from the bot's own jobs.json (localJobsClient), for
+ * personal and company bots alike, so there is no cloud refusal to explain
+ * here. Only the local client's own errors (quota, unknown job, validation)
+ * get rewritten; anything else keeps its real message.
  */
 export function jobsErrorMessage(err, ctx) {
     if (!(err instanceof BotApiError))
         return err instanceof Error ? err.message : String(err);
-    if (ctx.kind === "personal" && err.status === 403 && err.code === "CROSS_AGENT_JOB") {
-        return (`Scheduled jobs aren't available for personal bots yet — the cloud only accepts them from ` +
-            `company bots. Create ${ctx.botName} as a company bot (hq bot create ${ctx.botName} --kind company ` +
-            `--company <slug>) to schedule work, or wait for personal-bot support.`);
-    }
     if (err.status === 401)
         return "Not authenticated — the bot's credentials were refused. Try: hq bot restart " + ctx.botName;
     if (err.code === "JOB_QUOTA_EXCEEDED" || err.status === 409) {
@@ -355,13 +427,25 @@ export async function runBotJobs(nameArg, opts, deps) {
     const out = deps.out ?? ((line) => console.log(line));
     const ctx = { botName: name, kind };
     const quietOptionEnabled = deps.quietOptionEnabled ?? botJobQuietOptionEnabled;
+    const fleet = config.engine?.id === HQ_FLEET_RUNTIME_ENGINE_ID;
+    const localZone = (deps.timezone ?? machineTimezone)();
+    if (fleet && opts.quiet) {
+        refuse(`--quiet is not available for ${name}: it runs on the HQ Fleet Runtime, which posts every run's result to your HQ DM.`);
+    }
+    if (fleet && opts.tz?.trim() && opts.tz.trim() !== localZone) {
+        refuse(`${name} runs on the HQ Fleet Runtime, which runs jobs in this computer's time zone (${localZone}). Drop --tz.`);
+    }
     // The schedule lives with the bot: this bot runs on this computer, so its
     // jobs live in its folder and it fires them itself.
     let client;
     const jobsApi = async () => {
         if (client)
             return client;
-        client = deps.apiFor ? deps.apiFor(dir) : localJobsClient(dir);
+        client = deps.apiFor
+            ? deps.apiFor(dir)
+            : fleet
+                ? fleetJobsClient(config, (deps.fleetCron ?? fleetCronOps)(config.agentUid), localZone)
+                : localJobsClient(dir);
         return client;
     };
     if ([opts.add, opts.rm, opts.reschedule].filter((value) => value !== undefined).length > 1) {
@@ -378,7 +462,7 @@ export async function runBotJobs(nameArg, opts, deps) {
         }
         if (opts.every && opts.cron)
             refuse("Use --every or --cron, not both.");
-        const timezone = opts.tz?.trim() || (deps.timezone ?? machineTimezone)();
+        const timezone = opts.tz?.trim() || localZone;
         // An unknown zone would throw RangeError on every inbox poll; refuse it now.
         try {
             new Intl.DateTimeFormat("en-US", { timeZone: timezone });
@@ -448,6 +532,10 @@ export async function runBotJobs(nameArg, opts, deps) {
         }
         const words = schedule.human || describeSchedule(created);
         out(chalk.green(`Scheduled ${created.jobId}: ${name} will ${body.prompt.replace(/\s+/g, " ").slice(0, 120)} — ${words}.`));
+        if (fleet) {
+            out(chalk.gray(`It runs on this computer while ${name}'s HQ Fleet gateway is running, and posts the result to your HQ DM.`));
+            return;
+        }
         out(chalk.gray(`It runs on this computer while ${name} is running. If a run is due while the computer is asleep or ` +
             `${name} is stopped, it runs once, as a catch-up, the next time ${name} is running.`));
         return;

package/dist/commands/bot.d.ts

@@ -145,7 +145,6 @@ export interface BotCreateOptions {
     hqFleetRuntime?: boolean;
     legacyRuntime?: boolean;
     model?: string;
-    effort?: string;
     autoApprove?: boolean;
     daemon?: boolean;
     start?: boolean;
@@ -157,8 +156,6 @@ export interface BotCreateOptions {
     memory?: string;
     kind?: string;
     company?: string[];
-    /** Run the bot lean: no HQ hooks, MCP servers or setting sources (pack setup bots). */
-    lean?: boolean;
 }
 /**
  * Which way `hq bot create` went. For HQ's setup assistant all three are a
@@ -243,6 +240,10 @@ export declare function runBotProbe(opts: {
 export declare function runBotIntro(nameArg: string): Promise<void>;
 /** True when a bot of this name exists on this computer (its bot.json reads). */
 export declare function botExists(name: string): boolean;
+export type FleetRuntimeUpdateOutcome = "unchanged" | "updated" | "waiting";
+export declare function updateFleetRuntimeBot(nameArg: string, opts?: {
+    busy?: () => string | null;
+}): Promise<FleetRuntimeUpdateOutcome>;
 /** `hq bot restart <name>`: stop, then start (launchd when installed). */
 export declare function runBotRestart(nameArg: string, opts?: {
     json?: boolean;