clawmoney 0.17.41 → 0.17.43

package/dist/commands/task.d.ts

@@ -0,0 +1,3 @@
+export declare function taskStartCommand(): Promise<void>;
+export declare function taskStopCommand(): Promise<void>;
+export declare function taskStatusCommand(): Promise<void>;

package/dist/commands/task.js

@@ -0,0 +1,94 @@
+import { spawn } from "node:child_process";
+import { openSync, closeSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import chalk from "chalk";
+import ora from "ora";
+import { requireConfig } from "../utils/config.js";
+import { readTaskPid, isPidAlive } from "../task/daemon.js";
+const LOG_FILE = join(homedir(), ".clawmoney", "task.log");
+export async function taskStartCommand() {
+    const config = requireConfig();
+    const existing = readTaskPid();
+    if (existing !== null && isPidAlive(existing)) {
+        console.log(chalk.yellow(`Task daemon is already running (PID ${existing}). Use "clawmoney task stop" first.`));
+        return;
+    }
+    const spinner = ora("Starting Task daemon...").start();
+    try {
+        const thisDir = import.meta.url.replace("file://", "").replace(/\/[^/]+$/, "");
+        const parentDir = thisDir.replace(/\/[^/]+$/, "");
+        const daemonScript = join(parentDir, "task", "daemon.js");
+        // Open log file for stdout/stderr capture (daemon detaches from parent).
+        const out = openSync(LOG_FILE, "a");
+        const err = openSync(LOG_FILE, "a");
+        const child = spawn(process.execPath, [daemonScript], {
+            stdio: ["ignore", out, err],
+            detached: true,
+            env: {
+                ...process.env,
+                CLAWMONEY_DAEMON: "1",
+                // daemon reads these from env first, then ~/.clawmoney/config.yaml as fallback
+                API_KEY: config.api_key,
+                AGENT_ID: config.agent_id ?? "",
+                AGENT_NAME: config.agent_slug ?? "clawmoney-task",
+            },
+        });
+        child.unref();
+        // Release fds in the parent — keeping them open keeps node's event
+        // loop alive (the parent never exits), and stale parent processes
+        // mean each desktop dashboard refresh would re-spawn another daemon.
+        closeSync(out);
+        closeSync(err);
+        await new Promise((r) => setTimeout(r, 1000));
+        const pid = readTaskPid();
+        if (pid && isPidAlive(pid)) {
+            spinner.succeed(chalk.green(`Task daemon started (PID ${pid})`));
+            console.log(chalk.dim(`  Log file: ${LOG_FILE}`));
+            console.log(chalk.dim(`  Hub: wss://api.spareapi.ai/ws/relay`));
+        }
+        else {
+            spinner.fail(chalk.red(`Failed to start Task daemon. Check logs at: ${LOG_FILE}`));
+            process.exit(1);
+        }
+    }
+    catch (e) {
+        spinner.fail(chalk.red("Failed to start Task daemon"));
+        throw e;
+    }
+}
+export async function taskStopCommand() {
+    const pid = readTaskPid();
+    if (pid === null) {
+        console.log(chalk.dim("Task daemon is not running (no PID file)."));
+        return;
+    }
+    if (!isPidAlive(pid)) {
+        console.log(chalk.dim(`Task daemon PID ${pid} not alive. Cleaning up.`));
+        // daemon's own SIGTERM handler removes the PID file; if dead, we'd
+        // typically clean here. Skip for simplicity — next start replaces.
+        return;
+    }
+    try {
+        process.kill(pid, "SIGTERM");
+        console.log(chalk.green(`Task daemon stopped (PID ${pid}).`));
+    }
+    catch (e) {
+        console.error(chalk.red(`Failed to stop process ${pid}:`), e.message);
+    }
+    await new Promise((r) => setTimeout(r, 500));
+}
+export async function taskStatusCommand() {
+    const pid = readTaskPid();
+    if (pid === null) {
+        console.log(chalk.dim("Task daemon is not running."));
+        return;
+    }
+    if (isPidAlive(pid)) {
+        console.log(chalk.green(`Task daemon is running (PID ${pid}).`));
+        console.log(chalk.dim(`  Log file: ${LOG_FILE}`));
+    }
+    else {
+        console.log(chalk.yellow(`Task daemon PID ${pid} not alive (stale PID file).`));
+    }
+}

package/dist/index.js

@@ -367,6 +367,49 @@ market
         process.exit(1);
     }
 });
+// task (spareai-hub OpenCLI sync gateway)
+const task = program
+    .command('task')
+    .description('Task daemon: serve sync OpenCLI requests via spareai-hub');
+task
+    .command('start')
+    .description('Start Task daemon (background process)')
+    .action(async () => {
+    try {
+        const { taskStartCommand } = await import('./commands/task.js');
+        await taskStartCommand();
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+task
+    .command('stop')
+    .description('Stop Task daemon')
+    .action(async () => {
+    try {
+        const { taskStopCommand } = await import('./commands/task.js');
+        await taskStopCommand();
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+task
+    .command('status')
+    .description('Check Task daemon status')
+    .action(async () => {
+    try {
+        const { taskStatusCommand } = await import('./commands/task.js');
+        await taskStatusCommand();
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
 // gig (escrow tasks)
 const gig = program.command('gig').description('Gig marketplace: post and accept freelance tasks');
 gig

package/dist/task/daemon.d.ts

@@ -1,2 +1,3 @@
 #!/usr/bin/env tsx
-export {};
+export declare function readTaskPid(): number | null;
+export declare function isPidAlive(pid: number): boolean;

package/dist/task/daemon.js

@@ -20,9 +20,34 @@
  * No CLI integration yet — that lands in Phase 3 alongside the proper
  * `clawmoney task start` command.
  */
+import { readFileSync, writeFileSync, unlinkSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import YAML from "yaml";
 import { TaskWsClient } from "./ws-client.js";
 import { getSkill, listSkills } from "./skills/index.js";
-function loadConfigFromEnv() {
+const CONFIG_DIR = join(homedir(), ".clawmoney");
+const CONFIG_FILE = join(CONFIG_DIR, "config.yaml");
+const PID_FILE = join(CONFIG_DIR, "task.pid");
+function loadYamlConfig() {
+    if (!existsSync(CONFIG_FILE))
+        return {};
+    try {
+        return (YAML.parse(readFileSync(CONFIG_FILE, "utf-8")) ?? {});
+    }
+    catch {
+        return {};
+    }
+}
+function pickString(...candidates) {
+    for (const c of candidates) {
+        if (typeof c === "string" && c)
+            return c;
+    }
+    return undefined;
+}
+function loadConfig() {
+    const yaml = loadYamlConfig();
     const skillsEnv = process.env.SKILLS ?? "";
     const requested = skillsEnv
         .split(",")
@@ -41,9 +66,9 @@ function loadConfigFromEnv() {
     });
     return {
         hub_url: process.env.HUB_URL ?? "wss://api.spareapi.ai/ws/relay",
-        api_key: process.env.API_KEY ?? "",
-        agent_id: process.env.AGENT_ID,
-        agent_name: process.env.AGENT_NAME ?? "clawmoney-task",
+        api_key: pickString(process.env.API_KEY, yaml.api_key) ?? "",
+        agent_id: pickString(process.env.AGENT_ID, yaml.agent_id),
+        agent_name: pickString(process.env.AGENT_NAME, yaml.agent_slug) ?? "clawmoney-task",
         skills: filtered,
         max_concurrency: process.env.MAX_CONCURRENCY
             ? Number.parseInt(process.env.MAX_CONCURRENCY, 10)
@@ -52,6 +77,35 @@ function loadConfigFromEnv() {
         reconnect: { initial_ms: 1000, max_ms: 60_000, multiplier: 2 },
     };
 }
+export function readTaskPid() {
+    try {
+        const pid = parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10);
+        return Number.isFinite(pid) ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function writePid() {
+    writeFileSync(PID_FILE, String(process.pid), "utf-8");
+}
+function removePid() {
+    try {
+        unlinkSync(PID_FILE);
+    }
+    catch {
+        // ignore
+    }
+}
 async function handleTaskRequest(ws, req) {
     const startedAtMs = Date.now();
     const handler = getSkill(req.skill_id);
@@ -111,12 +165,22 @@ async function handleTaskRequest(ws, req) {
     }
 }
 function main() {
-    const config = loadConfigFromEnv();
+    const existing = readTaskPid();
+    if (existing !== null && isPidAlive(existing)) {
+        console.error(`[task] already running (PID ${existing})`);
+        process.exit(1);
+    }
+    const config = loadConfig();
+    if (!config.api_key) {
+        console.error("[task] api_key missing — set API_KEY env or run `clawmoney setup`");
+        process.exit(1);
+    }
     console.log(`[task] starting daemon hub=${config.hub_url} skills=[${config.skills.join(",")}]`);
     if (config.skills.length === 0) {
         console.error("[task] no skills to advertise — refusing to start");
         process.exit(1);
     }
+    writePid();
     // Belt-and-suspenders: even if every other handle (WS, heartbeat,
     // reconnect timer) somehow goes away simultaneously, this interval
     // is unref-less and ref-counted into the event loop, so the daemon
@@ -151,6 +215,7 @@ function main() {
     const shutdown = (signal) => {
         console.log(`[task] ${signal} — shutting down`);
         ws.stop();
+        removePid();
         setTimeout(() => process.exit(0), 200);
     };
     process.on("SIGINT", () => shutdown("SIGINT"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmoney",
-  "version": "0.17.41",
+  "version": "0.17.43",
   "description": "ClawMoney CLI -- Earn rewards with your AI agent",
   "type": "module",
   "bin": {