@rizzmo/tokochi-cli 0.1.2 → 0.1.4

package/README.md

@@ -3,15 +3,28 @@
 Connect local Codex, Claude Code, and GitHub Copilot token usage to your Tokochi.
 
 ```bash
-npx @rizzmo/tokochi-cli connect --url https://your-tokochi.app
+npm install -g @rizzmo/tokochi-cli
+tokochi connect
 ```
 
-The browser handles GitHub authentication and device approval. No token copying is required.
+The CLI connects to `https://www.tokochi.me` by default. The browser handles GitHub authentication and device approval; no token copying is required.
 
 ```bash
-npx @rizzmo/tokochi-cli sync
-npx @rizzmo/tokochi-cli status
-npx @rizzmo/tokochi-cli disconnect
+tokochi auto-sync enable --interval 15m
+tokochi auto-sync status
+tokochi auto-sync disable
+```
+
+Automatic syncing installs a user-level OS job: launchd on macOS, a systemd user timer on Linux, or Task Scheduler on Windows. Each run uploads only new events and exits; no terminal must remain open. The supported interval is 5 minutes to 24 hours.
+
+Manual commands remain available:
+
+```bash
+tokochi sync
+tokochi status
+tokochi disconnect
 ```
 
 Only event IDs, timestamps, agent/model names, and token counts are uploaded. Prompts and responses remain on the computer.
+
+Without a global installation, prefix commands with `npx @rizzmo/tokochi-cli`.

package/dist/auto-sync.d.ts

@@ -0,0 +1,12 @@
+export type AutoSyncStatus = {
+    enabled: boolean;
+    intervalMinutes?: number;
+    platform: NodeJS.Platform;
+};
+export declare function parseInterval(value?: string): number;
+export declare function enableAutoSync(intervalMinutes?: number, cliPath?: string): Promise<AutoSyncStatus>;
+export declare function disableAutoSync(): Promise<AutoSyncStatus>;
+export declare function getAutoSyncStatus(): Promise<AutoSyncStatus>;
+export declare function launchdPlist(nodePath: string, cliPath: string, intervalMinutes: number, logPath: string): string;
+export declare function systemdService(nodePath: string, cliPath: string): string;
+export declare function systemdTimer(intervalMinutes: number): string;

package/dist/auto-sync.js

@@ -0,0 +1,217 @@
+import { access, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir, platform, userInfo } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { spawn } from "node:child_process";
+const LABEL = "app.tokochi.autosync";
+const WINDOWS_TASK = "Tokochi Auto Sync";
+const DEFAULT_INTERVAL_MINUTES = 15;
+export function parseInterval(value = "15m") {
+    const match = /^(\d+)(m|h)$/.exec(value.trim().toLowerCase());
+    if (!match)
+        throw new Error("Interval must use minutes or hours, for example `15m` or `1h`.");
+    const amount = Number(match[1]);
+    const minutes = match[2] === "h" ? amount * 60 : amount;
+    if (!Number.isSafeInteger(minutes) || minutes < 5 || minutes > 1440) {
+        throw new Error("Auto-sync interval must be between 5 minutes and 24 hours.");
+    }
+    return minutes;
+}
+export async function enableAutoSync(intervalMinutes = DEFAULT_INTERVAL_MINUTES, cliPath = resolve(process.argv[1])) {
+    if (!Number.isSafeInteger(intervalMinutes) || intervalMinutes < 5 || intervalMinutes > 1440) {
+        throw new Error("Auto-sync interval must be between 5 minutes and 24 hours.");
+    }
+    const currentPlatform = platform();
+    if (currentPlatform === "darwin")
+        await enableLaunchd(intervalMinutes, cliPath);
+    else if (currentPlatform === "linux")
+        await enableSystemd(intervalMinutes, cliPath);
+    else if (currentPlatform === "win32")
+        await enableTaskScheduler(intervalMinutes, cliPath);
+    else
+        throw new Error(`Automatic syncing is not supported on ${currentPlatform}.`);
+    await saveState({ intervalMinutes, platform: currentPlatform });
+    return { enabled: true, intervalMinutes, platform: currentPlatform };
+}
+export async function disableAutoSync() {
+    const currentPlatform = platform();
+    if (currentPlatform === "darwin")
+        await disableLaunchd();
+    else if (currentPlatform === "linux")
+        await disableSystemd();
+    else if (currentPlatform === "win32")
+        await disableTaskScheduler();
+    else
+        throw new Error(`Automatic syncing is not supported on ${currentPlatform}.`);
+    await rm(statePath(), { force: true });
+    return { enabled: false, platform: currentPlatform };
+}
+export async function getAutoSyncStatus() {
+    const currentPlatform = platform();
+    const state = await loadState();
+    const enabled = await scheduleExists(currentPlatform);
+    return {
+        enabled,
+        intervalMinutes: enabled ? state?.intervalMinutes : undefined,
+        platform: currentPlatform,
+    };
+}
+export function launchdPlist(nodePath, cliPath, intervalMinutes, logPath) {
+    const args = [nodePath, cliPath, "sync"].map((value) => `      <string>${xml(value)}</string>`).join("\n");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+  <key>StartInterval</key>
+  <integer>${intervalMinutes * 60}</integer>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${xml(logPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xml(logPath)}</string>
+</dict>
+</plist>
+`;
+}
+export function systemdService(nodePath, cliPath) {
+    return `[Unit]
+Description=Sync local AI usage to Tokochi
+
+[Service]
+Type=oneshot
+ExecStart=${systemdEscape(nodePath)} ${systemdEscape(cliPath)} sync
+`;
+}
+export function systemdTimer(intervalMinutes) {
+    return `[Unit]
+Description=Sync Tokochi every ${intervalMinutes} minutes
+
+[Timer]
+OnBootSec=2min
+OnUnitActiveSec=${intervalMinutes}min
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`;
+}
+async function enableLaunchd(intervalMinutes, cliPath) {
+    const path = launchdPath();
+    await mkdir(dirname(path), { recursive: true });
+    await mkdir(dataDirectory(), { recursive: true, mode: 0o700 });
+    await run("launchctl", ["bootout", launchdDomain(), path], true);
+    await writeFile(path, launchdPlist(process.execPath, cliPath, intervalMinutes, logPath()), { mode: 0o600 });
+    await run("launchctl", ["bootstrap", launchdDomain(), path]);
+}
+async function disableLaunchd() {
+    const path = launchdPath();
+    await run("launchctl", ["bootout", launchdDomain(), path], true);
+    await rm(path, { force: true });
+}
+async function enableSystemd(intervalMinutes, cliPath) {
+    const directory = systemdDirectory();
+    await mkdir(directory, { recursive: true });
+    await writeFile(join(directory, "tokochi-sync.service"), systemdService(process.execPath, cliPath), { mode: 0o600 });
+    await writeFile(join(directory, "tokochi-sync.timer"), systemdTimer(intervalMinutes), { mode: 0o600 });
+    await run("systemctl", ["--user", "daemon-reload"]);
+    await run("systemctl", ["--user", "enable", "--now", "tokochi-sync.timer"]);
+}
+async function disableSystemd() {
+    await run("systemctl", ["--user", "disable", "--now", "tokochi-sync.timer"], true);
+    await rm(join(systemdDirectory(), "tokochi-sync.service"), { force: true });
+    await rm(join(systemdDirectory(), "tokochi-sync.timer"), { force: true });
+    await run("systemctl", ["--user", "daemon-reload"], true);
+}
+async function enableTaskScheduler(intervalMinutes, cliPath) {
+    const taskCommand = windowsQuote(process.execPath, cliPath, "sync");
+    await run("schtasks", [
+        "/Create", "/F", "/TN", WINDOWS_TASK, "/SC", "MINUTE", "/MO", String(intervalMinutes),
+        "/TR", taskCommand,
+    ]);
+}
+async function disableTaskScheduler() {
+    await run("schtasks", ["/Delete", "/F", "/TN", WINDOWS_TASK], true);
+}
+async function scheduleExists(currentPlatform) {
+    if (currentPlatform === "darwin")
+        return exists(launchdPath());
+    if (currentPlatform === "linux")
+        return exists(join(systemdDirectory(), "tokochi-sync.timer"));
+    if (currentPlatform === "win32")
+        return (await run("schtasks", ["/Query", "/TN", WINDOWS_TASK], true)).ok;
+    return false;
+}
+async function run(command, args, ignoreFailure = false) {
+    return new Promise((resolvePromise, reject) => {
+        const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+        let output = "";
+        child.stdout.on("data", (chunk) => { output += String(chunk); });
+        child.stderr.on("data", (chunk) => { output += String(chunk); });
+        child.on("error", (error) => {
+            if (ignoreFailure)
+                resolvePromise({ ok: false, output: error.message });
+            else
+                reject(error);
+        });
+        child.on("close", (code) => {
+            if (code === 0 || ignoreFailure)
+                resolvePromise({ ok: code === 0, output: output.trim() });
+            else
+                reject(new Error(output.trim() || `${command} exited with code ${code}`));
+        });
+    });
+}
+function dataDirectory() {
+    return join(homedir(), ".tokochi");
+}
+function statePath() {
+    return join(dataDirectory(), "auto-sync.json");
+}
+function logPath() {
+    return join(dataDirectory(), "auto-sync.log");
+}
+function launchdPath() {
+    return join(homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
+}
+function launchdDomain() {
+    return `gui/${userInfo().uid}`;
+}
+function systemdDirectory() {
+    return join(homedir(), ".config", "systemd", "user");
+}
+async function saveState(state) {
+    await mkdir(dataDirectory(), { recursive: true, mode: 0o700 });
+    await writeFile(statePath(), `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+}
+async function loadState() {
+    try {
+        return JSON.parse(await readFile(statePath(), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function xml(value) {
+    return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function systemdEscape(value) {
+    return `"${value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
+}
+function windowsQuote(...parts) {
+    return parts.map((part) => `"${part.replaceAll("\"", "\\\"")}"`).join(" ");
+}

package/dist/index.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 import { startDeviceFlow, pollForToken, uploadEvents } from "./api.js";
+import { disableAutoSync, enableAutoSync, getAutoSyncStatus, parseInterval } from "./auto-sync.js";
 import { openBrowser } from "./browser.js";
 import { collectUsageEvents } from "./collectors.js";
 import { deleteConfig, loadConfig, saveConfig } from "./config.js";
-const DEFAULT_URL = "https://tokochi.app";
+const DEFAULT_URL = "https://www.tokochi.me";
 const command = process.argv[2] ?? "help";
 try {
     if (command === "connect")
@@ -14,6 +15,8 @@ try {
         await status();
     else if (command === "disconnect")
         await disconnect();
+    else if (command === "auto-sync")
+        await autoSync();
     else if (command === "help" || command === "--help" || command === "-h")
         help();
     else
@@ -85,7 +88,7 @@ async function runSync(config) {
 async function status() {
     const config = await loadConfig();
     if (!config) {
-        console.log("Not connected. Run `npx @rizzmo/tokochi-cli connect --url https://your-tokochi.app`.");
+        console.log("Not connected. Run `tokochi connect`.");
         return;
     }
     const events = await collectUsageEvents();
@@ -106,8 +109,32 @@ async function disconnect() {
         method: "DELETE",
         headers: { authorization: `Bearer ${config.token}` },
     }).catch(() => undefined);
+    await disableAutoSync().catch(() => undefined);
     await deleteConfig();
-    console.log("Disconnected. This computer will no longer feed your Tokochi.");
+    console.log("Disconnected. This computer will no longer feed your Tokochi, and automatic feeding was disabled.");
+}
+async function autoSync() {
+    const action = process.argv[3] ?? "status";
+    if (action === "enable") {
+        await requireConfig();
+        const intervalMinutes = parseInterval(option("--interval") ?? "15m");
+        const result = await enableAutoSync(intervalMinutes);
+        console.log(`Automatic feeding enabled every ${result.intervalMinutes} minutes.`);
+        console.log("It runs as a user-level OS job and survives terminal closure and restarts.");
+    }
+    else if (action === "disable") {
+        await disableAutoSync();
+        console.log("Automatic feeding disabled.");
+    }
+    else if (action === "status") {
+        const result = await getAutoSyncStatus();
+        console.log(result.enabled
+            ? `Automatic feeding is enabled${result.intervalMinutes ? ` every ${result.intervalMinutes} minutes` : ""}.`
+            : "Automatic feeding is disabled.");
+    }
+    else {
+        throw new Error("Use `tokochi auto-sync enable`, `status`, or `disable`.");
+    }
 }
 function help() {
     console.log(`
@@ -117,9 +144,16 @@ Tokochi CLI
   tokochi sync                 Feed new local token events
   tokochi status               Show connection and feeding status
   tokochi disconnect           Remove this computer's connection
+  tokochi auto-sync enable     Schedule feeding every 15 minutes
+  tokochi auto-sync status     Show automatic feeding status
+  tokochi auto-sync disable    Remove the scheduled job
+
+Install globally:
+  npm install -g @rizzmo/tokochi-cli
+  tokochi connect
 
 Run without installing:
-  npx @rizzmo/tokochi-cli connect --url http://localhost:3000
+  npx @rizzmo/tokochi-cli connect
 `.trim());
 }
 async function requireConfig() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rizzmo/tokochi-cli",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Feed your Tokochi from local AI coding token usage.",
   "type": "module",
   "bin": {