opencode-routines 0.1.0

package/dist/tui.d.ts

@@ -0,0 +1,61 @@
+type TuiApi = {
+    route: {
+        current: {
+            name: string;
+            params?: Record<string, any>;
+        };
+        navigate?: (name: string, params?: Record<string, unknown>) => void;
+    };
+    client: {
+        session: {
+            prompt: (input: any) => Promise<unknown>;
+        };
+    };
+    ui: {
+        dialog: {
+            replace: (render: () => any) => void;
+            clear: () => void;
+        };
+        DialogAlert: (props: {
+            title: string;
+            message: string;
+        }) => any;
+        DialogPrompt: (props: {
+            title: string;
+            placeholder?: string;
+            onConfirm?: (value: string) => void;
+        }) => any;
+        DialogSelect: (props: {
+            title: string;
+            options: Array<{
+                title: string;
+                value: string;
+                description?: string;
+                footer?: string;
+            }>;
+            onSelect?: (option: {
+                value: string;
+            }) => void;
+        }) => any;
+        toast: (input: {
+            variant?: "info" | "success" | "warning" | "error";
+            title?: string;
+            message: string;
+        }) => void;
+    };
+    lifecycle: {
+        onDispose: (fn: () => void) => void;
+    };
+    keymap: {
+        registerLayer: (input: {
+            commands: any[];
+            bindings?: any[];
+        }) => unknown;
+    };
+};
+type TuiPlugin = (api: TuiApi, options?: Record<string, unknown>, meta?: Record<string, unknown>) => Promise<void>;
+declare const _default: {
+    id: string;
+    tui: TuiPlugin;
+};
+export default _default;

package/dist/tui.js

@@ -0,0 +1,210 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/tui.ts
+var loops = new Map;
+function activeSessionID(api) {
+  const route = api.route.current;
+  if (route.name !== "session")
+    return;
+  return typeof route.params?.sessionID === "string" ? route.params.sessionID : undefined;
+}
+function parseDurationSeconds(input) {
+  const match = input.trim().match(/^(\d+)(s|m|h)$/i);
+  if (!match)
+    return;
+  const value = Number(match[1]);
+  if (!Number.isFinite(value) || value <= 0)
+    return;
+  const unit = match[2].toLowerCase();
+  if (unit === "s")
+    return value;
+  if (unit === "m")
+    return value * 60;
+  return value * 3600;
+}
+function parseLoop(input) {
+  const trimmed = input.trim();
+  if (!trimmed)
+    return;
+  const [first, ...rest] = trimmed.split(/\s+/);
+  const intervalSeconds = parseDurationSeconds(first ?? "");
+  if (intervalSeconds === undefined)
+    return { prompt: trimmed };
+  const prompt = rest.join(" ").trim();
+  if (!prompt)
+    return;
+  return { intervalSeconds, prompt };
+}
+function loopID() {
+  return `loop_${Math.random().toString(16).slice(2, 10)}`;
+}
+async function submitPrompt(api, loop) {
+  loop.fires += 1;
+  await api.client.session.prompt({
+    path: { sessionID: loop.sessionID },
+    body: {
+      parts: [{ type: "text", text: loop.prompt }]
+    }
+  });
+}
+function scheduleFixed(api, loop) {
+  if (!loop.intervalSeconds)
+    return;
+  loop.timer = setTimeout(async () => {
+    if (!loops.has(loop.id))
+      return;
+    try {
+      await submitPrompt(api, loop);
+      scheduleFixed(api, loop);
+    } catch (error) {
+      loops.delete(loop.id);
+      api.ui.toast({
+        variant: "error",
+        title: "Loop stopped",
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }, loop.intervalSeconds * 1000);
+}
+function stopLoop(id) {
+  const loop = loops.get(id);
+  if (!loop)
+    return false;
+  if (loop.timer)
+    clearTimeout(loop.timer);
+  loops.delete(id);
+  return true;
+}
+function showLoops(api) {
+  const items = [...loops.values()];
+  if (items.length === 0) {
+    api.ui.dialog.replace(() => api.ui.DialogAlert({
+      title: "Loops",
+      message: "No active loops."
+    }));
+    return;
+  }
+  api.ui.dialog.replace(() => api.ui.DialogSelect({
+    title: "Active loops",
+    options: items.map((loop) => ({
+      title: `${loop.id} \xB7 ${loop.mode}${loop.intervalSeconds ? ` \xB7 every ${loop.intervalSeconds}s` : ""}`,
+      value: loop.id,
+      description: loop.prompt,
+      footer: `${loop.fires} fires \xB7 session ${loop.sessionID}`
+    })),
+    onSelect: (option) => {
+      stopLoop(String(option.value));
+      api.ui.toast({ variant: "success", message: `Stopped ${String(option.value)}` });
+      api.ui.dialog.clear();
+    }
+  }));
+}
+var tui = async (api) => {
+  api.lifecycle.onDispose(() => {
+    for (const id of [...loops.keys()])
+      stopLoop(id);
+  });
+  api.keymap.registerLayer({
+    commands: [
+      {
+        name: "routines.loop",
+        title: "Start same-session loop",
+        category: "Scheduler",
+        namespace: "palette",
+        slashName: "loop",
+        run() {
+          const sessionID = activeSessionID(api);
+          if (!sessionID) {
+            api.ui.toast({ variant: "warning", message: "Open a session before starting /loop." });
+            return;
+          }
+          api.ui.dialog.replace(() => api.ui.DialogPrompt({
+            title: "Start loop",
+            placeholder: "5m /babysit-prs  or  /babysit-prs",
+            onConfirm: (value) => {
+              const parsed = parseLoop(value);
+              if (!parsed) {
+                api.ui.toast({ variant: "warning", message: "Usage: /loop 5m <prompt> or /loop <prompt>" });
+                return;
+              }
+              const loop = {
+                id: loopID(),
+                sessionID,
+                prompt: parsed.prompt,
+                mode: parsed.intervalSeconds === undefined ? "dynamic" : "fixed",
+                intervalSeconds: parsed.intervalSeconds,
+                createdAt: new Date().toISOString(),
+                fires: 0
+              };
+              loops.set(loop.id, loop);
+              if (loop.mode === "fixed")
+                scheduleFixed(api, loop);
+              else
+                submitPrompt(api, loop);
+              api.ui.toast({
+                variant: "success",
+                title: "Loop started",
+                message: loop.mode === "fixed" ? `${loop.id} every ${loop.intervalSeconds}s` : `${loop.id} dynamic mode; use ScheduleWakeup to continue`
+              });
+              api.ui.dialog.clear();
+            }
+          }));
+        }
+      },
+      {
+        name: "routines.loops",
+        title: "List active loops",
+        category: "Scheduler",
+        namespace: "palette",
+        slashName: "loops",
+        run() {
+          showLoops(api);
+        }
+      },
+      {
+        name: "routines.stop_loop",
+        title: "Stop a same-session loop",
+        category: "Scheduler",
+        namespace: "palette",
+        slashName: "stop-loop",
+        run() {
+          showLoops(api);
+        }
+      },
+      {
+        name: "routines.schedule_standalone_session",
+        title: "Create standalone scheduled session",
+        category: "Scheduler",
+        namespace: "palette",
+        slashName: "schedule-standalone-session",
+        run() {
+          api.ui.dialog.replace(() => api.ui.DialogAlert({
+            title: "Standalone schedules",
+            message: "Use the ScheduleCreate tool (or natural language like 'create a standalone scheduled run...') to create durable OS-backed standalone sessions. The ambiguous /schedule command is intentionally not registered."
+          }));
+        }
+      }
+    ]
+  });
+};
+var tui_default = {
+  id: "opencode-routines-tui",
+  tui
+};
+export {
+  tui_default as default
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "opencode-routines",
+  "version": "0.1.0",
+  "description": "OpenCode routines: same-session loops, cron prompts, and host-backed standalone scheduled agents",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./tui": {
+      "types": "./dist/tui.d.ts",
+      "import": "./dist/tui.js"
+    }
+  },
+  "scripts": {
+    "build": "bun build src/index.ts src/tui.ts --outdir dist --target bun --format esm && tsc --emitDeclarationOnly",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "bun run clean && bun run build",
+    "release:patch": "npm version patch && npm publish",
+    "release:minor": "npm version minor && npm publish",
+    "release:major": "npm version major && npm publish",
+    "typecheck": "tsc --noEmit",
+    "test": "npm run build && node scripts/validate-routines-surface.mjs"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "routines",
+    "scheduler",
+    "loop",
+    "cron",
+    "launchd",
+    "systemd",
+    "automation",
+    "jobs"
+  ],
+  "author": "Emilio Esposito",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/EmilioEsposito/opencode-routines.git"
+  },
+  "bugs": {
+    "url": "https://github.com/EmilioEsposito/opencode-routines/issues"
+  },
+  "homepage": "https://github.com/EmilioEsposito/opencode-routines#readme",
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.0.162"
+  },
+  "devDependencies": {
+    "bun-types": "latest",
+    "typescript": "^5.7.3"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.0.0"
+  }
+}