@voidlabs.gg/voidshift-agents 0.4.2 → 0.4.4

package/dist/index.js

@@ -4,12 +4,16 @@ import { homedir } from 'node:os';
 import { basename, dirname, join, resolve, sep } from 'node:path';
 import { parseArgs } from 'node:util';
 import { fileURLToPath } from 'node:url';
-import { AGENTS, STEPS, TEMPLATES, isProducer, agentsDir, describeSteps, describeTriggers, describeWorkflow, stepEnabled, visibleAgents, readAgentsConfig, writeAgentsConfig, DEFAULTS } from "./config.js";
+import { AGENTS, STEPS, TEMPLATES, isProducer, agentsDir, describeSteps, describeTrigger, describeTriggers, describeWorkflow, stepEnabled, visibleAgents, readAgentsConfig, writeAgentsConfig, DEFAULTS } from "./config.js";
 import { controlChecks, controlCommands, controlUsage } from "./control.js";
-import { looksLikeLinearKey, readLinearKey, storeLinearKey } from "./keychain.js";
-import { startRunner, stopRunner } from "./launchd.js";
+import { keyStore, looksLikeLinearKey, readLinearKey, readSecret, storeLinearKey, storeSecret } from "./secrets.js";
+import { TRACKERS } from "./tracker.js";
+import { createVoidTrack } from "./voidtrack.js";
+import { parseCron } from "./cron.js";
+import { trackersInUse } from "./control.js";
+import { runnerService } from "./service.js";
 import { createLinear } from "./linear.js";
-import { duplicateTriggerWarnings, moveKey, parseTrigger, renameKey, sameTrigger, validateConfig, validateWorkflow, workflowsUsing } from "./manage.js";
+import { TRIGGER_FORMS, duplicateTriggerWarnings, moveKey, parseTrigger, renameKey, sameTrigger, validateConfig, validateWorkflow, workflowsUsing } from "./manage.js";
 import { parseStep, resolveName, stepNames } from "./names.js";
 import { findRepos } from "./repos.js";
 import { defaultBranch, sh } from "./git.js";
@@ -81,30 +85,32 @@ async function chooseHomes(ui, configDir, saved) {
     return homes;
 }
 // Checks the key against Linear, and only then stores it.
-async function verifyAndStore(key, info, warn) {
+async function verifyAndStore(configDir, key, info, warn, kind = 'linear') {
+    const name = TRACKERS[kind].name;
     try {
-        const me = await createLinear(key).viewer();
-        if (!storeLinearKey(key)) {
-            warn('Linear accepted the key but the Keychain did not store it.');
+        const me = await (kind === 'voidtrack' ? createVoidTrack(key) : createLinear(key)).viewer();
+        if (!(kind === 'voidtrack' ? storeSecret(configDir, 'voidtrack', key) : storeLinearKey(configDir, key))) {
+            warn(`${name} accepted the key but it could not be stored in ${keyStore()}.`);
             return null;
         }
-        info(`Linear connected as ${me.name}. Key stored in your macOS Keychain.`);
+        info(`${name} connected as ${me.name}. Key stored in ${keyStore()}.`);
         return me.name;
     }
     catch (err) {
-        warn(`Linear did not accept that key: ${err.message}. Nothing was stored.`);
+        warn(`${name} did not accept that key: ${err.message}. Nothing was stored.`);
         return null;
     }
 }
 // Asks for the key, checks it against Linear, and only then stores it.
-async function setupKey(ui) {
-    ui.info('Agents need a Linear personal API key (Linear > Settings > Security & access > API keys).');
-    const key = await ui.secret('Paste your Linear API key', (v) => (looksLikeLinearKey(v.trim()) ? undefined : 'Linear keys start with lin_api_'));
-    return verifyAndStore(key.trim(), ui.info, ui.warn);
+async function setupKey(ui, configDir, kind = 'linear') {
+    const { name, keyHint } = TRACKERS[kind];
+    ui.info(`Agents need a ${name} API key (${keyHint}).`);
+    const key = await ui.secret(`Paste your ${name} API key`, (v) => kind === 'linear' ? (looksLikeLinearKey(v.trim()) ? undefined : 'Linear keys start with lin_api_') : v.trim() ? undefined : 'Required');
+    return verifyAndStore(configDir, key.trim(), ui.info, ui.warn, kind);
 }
-async function currentLinearUser() {
+async function currentLinearUser(configDir) {
     try {
-        return readLinearKey() ? (await linear().viewer()).name : null;
+        return readLinearKey(configDir) ? (await linear(configDir).viewer()).name : null;
     }
     catch {
         return null;
@@ -181,8 +187,8 @@ function syncLinks(chosen, all, enabled, log) {
             log(`Agents linked in ${homeLabel(home)}: ${linked} linked${skipped ? `, ${skipped} skipped (something else is already there)` : ''}`);
     }
 }
-function linear() {
-    const key = readLinearKey();
+function linear(configDir) {
+    const key = readLinearKey(configDir);
     if (!key)
         throw new Error('No Linear API key. Run vsf agents key');
     return createLinear(key);
@@ -277,11 +283,22 @@ async function promptWorkflow(ui, config, teams, current = {}, edit = false) {
     if (!triggers) {
         triggers = [];
         do {
-            const team = teams.length
-                ? await ui.select(triggers.length ? 'Also start for cards in which Linear team?' : 'Starts when a card in which Linear team...', teams.map((t) => ({ value: t.key, label: `${t.key}  ${t.name}`, hint: t.mine ? 'your team' : undefined })), myTeams.length === 1 ? myTeams[0].key : undefined)
-                : (await ui.text('Starts when a card in which Linear team key...', { validate: (v) => (v.trim() ? undefined : 'Required') })).trim().toUpperCase();
+            const source = await ui.select(triggers.length ? 'Also start it when...' : 'Starts when...', [
+                { value: 'linear', label: 'A Linear card gets a label' },
+                { value: 'voidtrack', label: 'A VoidTrack card gets a label' },
+                { value: 'cron', label: 'On a schedule', hint: 'runs on a standing task, no card' },
+            ], 'linear');
+            if (source === 'cron') {
+                const schedule = (await ui.text('Cron schedule (minute hour day month weekday)', { initial: '0 5 * * 1', validate: (v) => (parseCron(v) ? undefined : 'Five fields, like 0 5 * * 1') })).trim();
+                const task = (await ui.text('What should each run work on?', { placeholder: 'Update the dependencies and fix what breaks', validate: (v) => (v.trim() ? undefined : 'Required') })).trim();
+                triggers.push({ source: 'cron', schedule, task });
+                continue;
+            }
+            const team = source === 'linear' && teams.length
+                ? await ui.select('A card in which Linear team...', teams.map((t) => ({ value: t.key, label: `${t.key}  ${t.name}`, hint: t.mine ? 'your team' : undefined })), myTeams.length === 1 ? myTeams[0].key : undefined)
+                : (await ui.text(`A card in which ${TRACKERS[source].name} team key...`, { validate: (v) => (v.trim() ? undefined : 'Required') })).trim().toUpperCase();
             const label = (await ui.text('...gets which label?', { initial: 'vs-plan', validate: (v) => (v.trim() ? undefined : 'Required') })).trim();
-            triggers.push({ source: 'linear', team, label });
+            triggers.push({ source, team, label });
         } while (await ui.confirm('Add another way to start this workflow?', false));
     }
     let steps = w.steps?.length && (await keep('steps', describeSteps(w.steps))) ? w.steps : undefined;
@@ -341,7 +358,7 @@ async function setupWorkflows(ui, config, teams, log) {
 // One entry per command, in the order help lists them.
 const USAGE = [
     ['workflows [--json]', 'List workflows in the order they match'],
-    ['workflow add [NAME] [--trigger TEAM:LABEL]... [--steps dev,qa | --template build] [--project P] [--rounds N]', 'Create a workflow; prompts for what is missing'],
+    ['workflow add [NAME] [--trigger TEAM:LABEL]... [--steps dev,qa | --template build] [--project P] [--rounds N]', 'Create a workflow; prompts for what is missing. A trigger is TEAM:LABEL (Linear), voidtrack:TEAM:LABEL or "cron:SCHEDULE:TASK"'],
     ['workflow show NAME [--json]', 'Show one workflow'],
     ['workflow edit NAME [--trigger T:L]... [--add-trigger T:L] [--remove-trigger T:L] [--steps S | --template T] [--project P] [--rounds N]', 'Change a workflow; no flags asks'],
     ['workflow rename OLD NEW', 'Rename a workflow, keeping its place'],
@@ -356,7 +373,7 @@ const USAGE = [
     ['homes [--json]', 'Show where the agents are linked'],
     ['link DIR [--claude | --codex]', 'Link the agents into a config folder'],
     ['unlink DIR', 'Remove the agents from a config folder'],
-    ['key', 'Store or replace the Linear API key (reads stdin without a terminal)'],
+    ['key [--voidtrack]', 'Store or replace the Linear or VoidTrack API key (reads stdin without a terminal)'],
     ['help [COMMAND]', 'Show this list, or one command'],
 ];
 const usageOf = (name) => USAGE.filter(([c]) => c === name || c.startsWith(`${name} `))
@@ -441,7 +458,7 @@ function readWorkflowFlags(v, config) {
         for (const t of v.trigger) {
             const parsed = parseTrigger(t);
             if (!parsed)
-                return { error: `Bad trigger ${t}. Use TEAM:LABEL, like ENG:vs-plan.`, code: 2 };
+                return { error: `Bad trigger ${t}. Use ${TRIGGER_FORMS}.`, code: 2 };
             flags.triggers.push(parsed);
         }
     }
@@ -489,7 +506,7 @@ function pickWorkflow(config, input, ctx) {
 }
 async function teamsOrNull(ctx) {
     try {
-        return await linear().teams();
+        return await linear(ctx.configDir).teams();
     }
     catch (err) {
         ctx.log(`Could not list Linear teams: ${err.message}`);
@@ -590,7 +607,7 @@ const workflowSubs = {
         else {
             ctx.log(`Workflow ${name}: ${describeWorkflow(w)}`);
             for (const t of w.triggers)
-                ctx.log(`Trigger: ${t.team} + ${t.label}`);
+                ctx.log(`Trigger: ${describeTrigger(t)}${t.source === 'cron' ? `, task: ${t.task}` : ''}`);
             ctx.log(`Steps: ${describeSteps(w.steps)}`);
             ctx.log(`Project: ${w.project}`);
             ctx.log(`Rounds: ${w.maxRounds}`);
@@ -637,7 +654,7 @@ const workflowSubs = {
         for (const t of (v['add-trigger'] ?? [])) {
             const parsed = parseTrigger(t);
             if (!parsed) {
-                ctx.log(`Bad trigger ${t}. Use TEAM:LABEL, like ENG:vs-plan.`);
+                ctx.log(`Bad trigger ${t}. Use ${TRIGGER_FORMS}.`);
                 return 2;
             }
             if (!next.triggers.some((x) => sameTrigger(x, parsed)))
@@ -1045,22 +1062,26 @@ const agents = {
                 config.models = { ...DEFAULTS.models };
         }
         config.engine = engine;
-        const name = await currentLinearUser();
+        const name = await currentLinearUser(ctx.configDir);
         if (!name || !(await ui.confirm(`Keep using Linear as ${name}?`))) {
-            if (!(await setupKey(ui)))
+            if (!(await setupKey(ui, ctx.configDir)))
                 throw new Error('Linear is not connected. Run vsf setup agents to retry.');
         }
         await setupProjects(ui, config, ctx.log);
-        await setupWorkflows(ui, config, await linear().teams(), ctx.log);
+        await setupWorkflows(ui, config, await linear(ctx.configDir).teams(), ctx.log);
         writeAgentsConfig(ctx.configDir, config);
-        if (Object.keys(config.workflows).length && (await ui.confirm('Start the background runner now? It checks Linear every minute for cards that start your workflows.'))) {
-            const ok = startRunner(ctx.home, [...ctx.selfCommand, 'agents', 'tick'], join(agentsDir(ctx.configDir), 'runner.log'));
+        if (trackersInUse(config).includes('voidtrack') && !readSecret(ctx.configDir, 'voidtrack')) {
+            if (!(await setupKey(ui, ctx.configDir, 'voidtrack')))
+                ctx.log('VoidTrack is not connected yet. Run vsf agents key --voidtrack.');
+        }
+        if (Object.keys(config.workflows).length && (await ui.confirm('Start the background runner now? Every minute it checks for cards and schedules that start your workflows.'))) {
+            const ok = runnerService().start(ctx.home, [...ctx.selfCommand, 'agents', 'tick'], join(agentsDir(ctx.configDir), 'runner.log'));
             ctx.log(ok ? 'Runner started.' : 'Could not start the runner. Try vsf agents start.');
         }
         ctx.log('In Claude Code or Codex, connect Linear too, then use /vs-plan, /vs-plan-review and /vs-publish on a card.');
     },
     async uninstall(ctx) {
-        stopRunner(ctx.home);
+        runnerService().stop(ctx.home);
         syncLinks([], candidateHomes(ctx.configDir, readAgentsConfig(ctx.configDir).homes), [], ctx.log);
         ctx.log('Agents unlinked and the runner stopped. Config and the Linear key were kept.');
     },
@@ -1077,12 +1098,19 @@ const agents = {
                 ? { name: `agents in ${homeLabel(h)}`, status: 'ok', detail: `${wanted.length} linked` }
                 : { name: `agents in ${homeLabel(h)}`, status: 'warn', detail: `missing ${missing.join(', ')}`, fix: `vsf agents link ${tilde(h.dir)}` });
         }
-        try {
-            const me = await linear().viewer();
-            checks.push({ name: 'Linear', status: 'ok', detail: `connected as ${me.name}` });
-        }
-        catch (err) {
-            checks.push({ name: 'Linear', status: 'fail', detail: err.message, fix: 'vsf agents key' });
+        const inUse = trackersInUse(saved);
+        for (const kind of inUse.length ? inUse : ['linear']) {
+            const { name } = TRACKERS[kind];
+            try {
+                const key = readSecret(ctx.configDir, kind);
+                if (!key)
+                    throw new Error(`No ${name} API key`);
+                const me = await (kind === 'voidtrack' ? createVoidTrack(key) : createLinear(key)).viewer();
+                checks.push({ name, status: 'ok', detail: `connected as ${me.name}` });
+            }
+            catch (err) {
+                checks.push({ name, status: 'fail', detail: err.message, fix: `vsf agents key${kind === 'linear' ? '' : ` --${kind}`}` });
+            }
         }
         const workflows = Object.entries(saved.workflows);
         const broken = workflows.filter(([, c]) => !saved.projects[c.project] || !isRepo(saved.projects[c.project].path)).map(([n]) => n);
@@ -1134,21 +1162,26 @@ const agents = {
         link: homeCommands.link,
         unlink: homeCommands.unlink,
         async key(args, ctx) {
-            const p = begin('key', args, {}, ctx);
+            const p = begin('key', args, { voidtrack: { type: 'boolean' } }, ctx);
             if (typeof p === 'number')
                 return p;
             if (p.positionals.length) {
                 ctx.log('Keys are not accepted on the command line. Pipe the key in instead.');
                 return 2;
             }
+            const kind = p.values.voidtrack ? 'voidtrack' : 'linear';
             if (interactive())
-                return (await setupKey(ctx.ui)) ? 0 : 1;
+                return (await setupKey(ctx.ui, ctx.configDir, kind)) ? 0 : 1;
             const key = readFileSync(0, 'utf8').trim();
-            if (!looksLikeLinearKey(key)) {
+            if (kind === 'linear' && !looksLikeLinearKey(key)) {
                 ctx.log('Linear keys start with lin_api_');
                 return 2;
             }
-            return (await verifyAndStore(key, ctx.log, ctx.log)) ? 0 : 1;
+            if (!key) {
+                ctx.log('No key on stdin.');
+                return 2;
+            }
+            return (await verifyAndStore(ctx.configDir, key, ctx.log, ctx.log, kind)) ? 0 : 1;
         },
         async help(args, ctx) {
             const want = args.join(' ').trim();

package/dist/launchd.d.ts

@@ -5,3 +5,4 @@ export declare function runnerEnv(): Record<string, string>;
 export declare const runnerLoaded: () => boolean;
 export declare function startRunner(home: string, program: string[], logPath: string): boolean;
 export declare function stopRunner(home: string): void;
+export declare function parsePlistArgs(plist: string): string[];

package/dist/launchd.js

@@ -66,3 +66,9 @@ export function stopRunner(home) {
         launchctl(['bootout', `${domain()}/${LABEL}`]);
     rmSync(plistPath(home), { force: true });
 }
+// The <string> values of a launchd plist's ProgramArguments.
+export function parsePlistArgs(plist) {
+    const block = /<key>ProgramArguments<\/key>\s*<array>([\s\S]*?)<\/array>/.exec(plist)?.[1] ?? '';
+    const unxml = (s) => s.replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&');
+    return [...block.matchAll(/<string>([\s\S]*?)<\/string>/g)].map((m) => unxml(m[1]));
+}

package/dist/linear.d.ts

@@ -20,7 +20,7 @@ export declare function createLinear(apiKey: string): {
         name: string;
         mine: boolean;
     }[]>;
-    myCardsWithLabel(label: string): Promise<Card[]>;
+    myCardsWithLabel(label: string, team: string): Promise<Card[]>;
     card(identifier: string): Promise<Card>;
     comments(identifier: string): Promise<{
         body: string;

package/dist/linear.js

@@ -79,14 +79,14 @@ export function createLinear(apiKey) {
             const all = d?.teams?.nodes ?? [];
             return all.map((t) => ({ ...t, mine: mine.has(t.key) })).sort((a, b) => Number(b.mine) - Number(a.mine));
         },
-        // My cards carrying the trigger label.
-        async myCardsWithLabel(label) {
+        // My cards in the team carrying the trigger label.
+        async myCardsWithLabel(label, team) {
             const d = await gql('myCards', `query MyCards($label: String!) {
           issues(first: 20, orderBy: createdAt, filter: { assignee: { isMe: { eq: true } }, labels: { name: { eq: $label } } }) {
             nodes { ${CARD_FIELDS} }
           }
         }`, { label });
-            return (d?.issues?.nodes ?? []).map(mapCard);
+            return (d?.issues?.nodes ?? []).map(mapCard).filter((c) => c.teamKey === team);
         },
         async card(identifier) {
             const d = await gql('card', `query Card($id: String!) { issue(id: $id) { ${CARD_FIELDS} } }`, { id: identifier });

package/dist/manage.d.ts

@@ -1,5 +1,6 @@
 import { type AgentsConfig, type Trigger, type Workflow } from './config.ts';
 export declare function validateWorkflow(config: Pick<AgentsConfig, 'enabled' | 'projects'>, workflow: Workflow): string[];
+export declare const TRIGGER_FORMS = "TEAM:LABEL (Linear), voidtrack:TEAM:LABEL, or cron:SCHEDULE:TASK";
 export declare function parseTrigger(input: string): Trigger | null;
 export declare const sameTrigger: (a: Trigger, b: Trigger) => boolean;
 export declare function duplicateTriggerWarnings(workflows: Record<string, Workflow>, name: string, workflow: Workflow): string[];

package/dist/manage.js

@@ -1,6 +1,7 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { AGENTS, STEPS } from "./config.js";
+import { AGENTS, STEPS, describeTrigger, triggerSpec } from "./config.js";
+import { parseCron } from "./cron.js";
 const isInt = (v, min, max) => typeof v === 'number' && Number.isInteger(v) && v >= min && v <= max;
 // Everything wrong with one workflow, in plain words. Empty means it is fine.
 export function validateWorkflow(config, workflow) {
@@ -8,10 +9,20 @@ export function validateWorkflow(config, workflow) {
     if (!workflow.triggers?.length)
         problems.push('Needs at least one trigger.');
     for (const t of workflow.triggers ?? []) {
-        if (!t.team?.trim())
-            problems.push('A trigger has no team.');
-        if (!t.label?.trim())
-            problems.push('A trigger has no label.');
+        if (t.source === 'cron') {
+            if (!parseCron(t.schedule ?? ''))
+                problems.push(`Schedule ${t.schedule} is not a five field cron schedule, like 0 5 * * 1.`);
+            if (!t.task?.trim())
+                problems.push('A schedule has no task.');
+        }
+        else if (t.source !== 'linear' && t.source !== 'voidtrack')
+            problems.push(`Unknown trigger source ${t.source}.`);
+        else {
+            if (!t.team?.trim())
+                problems.push('A trigger has no team.');
+            if (!t.label?.trim())
+                problems.push('A trigger has no label.');
+        }
     }
     if (!workflow.steps?.length)
         problems.push('Needs at least one step.');
@@ -27,16 +38,27 @@ export function validateWorkflow(config, workflow) {
         problems.push('Rounds must be a whole number from 1 to 9.');
     return problems;
 }
-// "ENG:vs-plan" into a trigger; the team is upper-cased.
+export const TRIGGER_FORMS = 'TEAM:LABEL (Linear), voidtrack:TEAM:LABEL, or cron:SCHEDULE:TASK';
+// "ENG:vs-plan" (Linear, also "linear:ENG:vs-plan"), "voidtrack:ORG:vs-start"
+// or "cron:0 5 * * 1:Update the dependencies" into a trigger. Teams are
+// upper-cased; a schedule must parse.
 export function parseTrigger(input) {
-    const i = input.indexOf(':');
-    if (i < 0)
+    const text = input.trim();
+    // A source prefix decides the form; a bare TEAM:LABEL is Linear.
+    if (text.startsWith('cron:')) {
+        const cron = /^cron:([^:]+):([\s\S]+)$/.exec(text);
+        const schedule = cron?.[1].trim().replace(/\s+/g, ' ') ?? '';
+        const task = cron?.[2].trim() ?? '';
+        return parseCron(schedule) && task ? { source: 'cron', schedule, task } : null;
+    }
+    const m = /^(linear|voidtrack):/.test(text) ? /^(linear|voidtrack):([^:]+):(.+)$/.exec(text) : /^()([^:]+):(.+)$/.exec(text);
+    if (!m)
         return null;
-    const team = input.slice(0, i).trim().toUpperCase();
-    const label = input.slice(i + 1).trim();
-    return team && label ? { source: 'linear', team, label } : null;
+    const team = m[2].trim().toUpperCase();
+    const label = m[3].trim();
+    return team && label ? { source: (m[1] || 'linear'), team, label } : null;
 }
-export const sameTrigger = (a, b) => a.team === b.team && a.label === b.label;
+export const sameTrigger = (a, b) => triggerSpec(a) === triggerSpec(b);
 // Warning lines for triggers this workflow shares with another one. Only the
 // first workflow in order starts a card, so the rest never get it.
 export function duplicateTriggerWarnings(workflows, name, workflow) {
@@ -47,7 +69,7 @@ export function duplicateTriggerWarnings(workflows, name, workflow) {
         for (const other of owners) {
             if (other === name)
                 continue;
-            lines.push(`Warning: ${other} also starts on ${t.team} + ${t.label}, and ${first} wins. vsf agents workflow move changes the order.`);
+            lines.push(`Warning: ${other} also starts on ${describeTrigger(t)}, and ${first} wins. vsf agents workflow move changes the order.`);
         }
     }
     return lines;

package/dist/runner.d.ts

@@ -1,9 +1,10 @@
 import { type AgentsConfig, type Workflow, type Project, type StepId, type Trigger } from './config.ts';
-import type { Card, Linear } from './linear.ts';
+import type { Card } from './linear.ts';
+import { type Tracker, type Trackers } from './tracker.ts';
 export interface RunContext {
     configDir: string;
     config: AgentsConfig;
-    linear: Linear;
+    trackers: Trackers;
     log: (line: string) => void;
     selfCommand: string[];
 }
@@ -11,13 +12,19 @@ export declare function summarize(output: string): string;
 export declare function runCard(card: Card, trigger: Trigger, workflowName: string, workflow: Workflow, project: Project, rc: RunContext, opts?: {
     from?: StepId;
 }): Promise<'verified' | 'changes' | 'parked'>;
-export declare function nextJob(rc: RunContext, only?: string, workflowName?: string): Promise<{
+type Job = {
     card: Card;
     trigger: Trigger;
     workflow: string;
-} | null>;
-export declare function cancelCard(linear: Linear, configDir: string, cardId: string, label: string): Promise<boolean>;
+};
+export declare function cronCard(workflow: string, task: string, at: Date): Card;
+export declare function nextJob(rc: RunContext, only?: string, workflowName?: string, opts?: {
+    force?: boolean;
+    now?: Date;
+}): Promise<Job | null>;
+export declare function cancelCard(tracker: Tracker, configDir: string, cardId: string, label: string, source?: 'linear' | 'voidtrack'): Promise<boolean>;
 export declare function tick(rc: RunContext, only?: string, opts?: {
     workflow?: string;
     from?: StepId;
 }): Promise<number>;
+export {};