ai-todo-cli 0.1.0

package/README.md

@@ -0,0 +1,50 @@
+# ai-todo-cli
+
+CLI tool for AI agents to interact with [ai-todo](https://ai-todo.stringzhao.life).
+
+All commands are dynamically discovered from the server. All output is JSON.
+
+## Install
+
+```bash
+npm install -g ai-todo-cli
+```
+
+## Login
+
+```bash
+ai-todo login
+```
+
+For headless environments:
+
+```bash
+ai-todo login --token <jwt>
+```
+
+## Usage
+
+```bash
+ai-todo tasks:list
+ai-todo tasks:list --filter today
+ai-todo tasks:create --title "Review PR" --priority 1
+ai-todo tasks:complete --id <task-id>
+ai-todo tasks:delete --id <task-id>
+ai-todo tasks:add-log --id <task-id> --content "Done with phase 1"
+ai-todo spaces:list
+```
+
+Run `ai-todo --help` to see all available commands (fetched from server).
+
+## For AI Agents
+
+This CLI is designed for AI agent integration. Key features:
+
+- All output is structured JSON
+- Exit codes: 0 = success, 1 = error, 2 = auth required
+- Commands are dynamically loaded from `/api/manifest`
+- No interactive prompts — all input via flags
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,284 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/auth.ts
+import { createServer } from "http";
+import { randomUUID } from "crypto";
+import open from "open";
+
+// src/config.ts
+import { homedir } from "os";
+import { join } from "path";
+var API_BASE_URL = process.env.AI_TODO_API_URL ?? "https://ai-todo.stringzhao.life";
+var CONFIG_DIR = join(homedir(), ".config", "ai-todo");
+var CREDENTIALS_PATH = join(CONFIG_DIR, "credentials.json");
+
+// src/credentials.ts
+import { readFileSync, writeFileSync, mkdirSync, unlinkSync } from "fs";
+import { dirname } from "path";
+function loadCredentials() {
+  try {
+    const data = readFileSync(CREDENTIALS_PATH, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function saveCredentials(creds) {
+  mkdirSync(dirname(CREDENTIALS_PATH), { recursive: true, mode: 448 });
+  writeFileSync(CREDENTIALS_PATH, JSON.stringify(creds, null, 2), {
+    mode: 384
+  });
+}
+function clearCredentials() {
+  try {
+    unlinkSync(CREDENTIALS_PATH);
+  } catch {
+  }
+}
+
+// src/auth.ts
+var TIMEOUT_MS = 12e4;
+async function login(tokenDirect) {
+  if (tokenDirect) {
+    saveCredentials({ access_token: tokenDirect, user_id: "", email: "" });
+    console.log(JSON.stringify({ success: true, message: "Token saved" }));
+    return;
+  }
+  const state = randomUUID();
+  return new Promise((resolve, reject) => {
+    const server = createServer((req, res) => {
+      if (req.method === "OPTIONS") {
+        res.writeHead(204, {
+          "Access-Control-Allow-Origin": new URL(API_BASE_URL).origin,
+          "Access-Control-Allow-Methods": "POST, OPTIONS",
+          "Access-Control-Allow-Headers": "Content-Type",
+          "Access-Control-Max-Age": "86400"
+        });
+        res.end();
+        return;
+      }
+      if (req.method === "POST" && req.url === "/callback") {
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk;
+        });
+        req.on("end", () => {
+          try {
+            const data = JSON.parse(body);
+            if (data.state !== state) {
+              res.writeHead(400, {
+                "Content-Type": "application/json",
+                "Access-Control-Allow-Origin": new URL(API_BASE_URL).origin
+              });
+              res.end(JSON.stringify({ error: "State mismatch" }));
+              return;
+            }
+            saveCredentials({
+              access_token: data.access_token,
+              user_id: data.user_id,
+              email: data.email
+            });
+            res.writeHead(200, {
+              "Content-Type": "application/json",
+              "Access-Control-Allow-Origin": new URL(API_BASE_URL).origin
+            });
+            res.end(JSON.stringify({ success: true }));
+            console.log(JSON.stringify({
+              success: true,
+              email: data.email,
+              message: "Login successful"
+            }));
+            server.close();
+            resolve();
+          } catch {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Invalid request" }));
+          }
+        });
+        return;
+      }
+      res.writeHead(404);
+      res.end();
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        reject(new Error("Failed to start local server"));
+        return;
+      }
+      const port = addr.port;
+      const authUrl = `${API_BASE_URL}/auth/cli?port=${port}&state=${state}`;
+      console.log(JSON.stringify({
+        message: "Opening browser for login...",
+        url: authUrl
+      }));
+      open(authUrl).catch(() => {
+        console.log(JSON.stringify({
+          message: "Could not open browser. Please visit this URL manually:",
+          url: authUrl
+        }));
+      });
+    });
+    const timer = setTimeout(() => {
+      server.close();
+      console.log(JSON.stringify({ error: "Login timed out" }));
+      process.exit(1);
+    }, TIMEOUT_MS);
+    server.on("close", () => clearTimeout(timer));
+  });
+}
+
+// src/manifest.ts
+async function fetchManifest() {
+  const res = await fetch(`${API_BASE_URL}/api/manifest`);
+  if (!res.ok) {
+    console.log(JSON.stringify({ error: "Failed to fetch manifest", status: res.status }));
+    process.exit(1);
+  }
+  return res.json();
+}
+
+// src/client.ts
+async function apiRequest(method, pathTemplate, pathParams, queryParams, bodyParams, fixedBody) {
+  const creds = loadCredentials();
+  if (!creds) {
+    console.log(JSON.stringify({ error: "Not logged in. Run: ai-todo login" }));
+    process.exit(2);
+  }
+  let path = pathTemplate;
+  for (const [key, value] of Object.entries(pathParams)) {
+    path = path.replace(`:${key}`, encodeURIComponent(value));
+  }
+  const url = new URL(path, API_BASE_URL);
+  for (const [key, value] of Object.entries(queryParams)) {
+    if (value !== void 0 && value !== "") {
+      url.searchParams.set(key, value);
+    }
+  }
+  const headers = {
+    Authorization: `Bearer ${creds.access_token}`
+  };
+  let body;
+  const mergedBody = { ...bodyParams, ...fixedBody };
+  if (method !== "GET" && method !== "DELETE" && Object.keys(mergedBody).length > 0) {
+    headers["Content-Type"] = "application/json";
+    body = JSON.stringify(mergedBody);
+  }
+  const res = await fetch(url.toString(), { method, headers, body });
+  if (res.status === 401) {
+    console.log(JSON.stringify({ error: "Unauthorized. Run: ai-todo login" }));
+    process.exit(2);
+  }
+  if (res.status === 204) {
+    return { data: { success: true }, status: 204 };
+  }
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    console.log(JSON.stringify({ error: data.error ?? "Request failed", status: res.status }));
+    process.exit(1);
+  }
+  return { data, status: res.status };
+}
+
+// src/commands.ts
+function registerDynamicCommands(program2, operations) {
+  for (const op of operations) {
+    const cmd = program2.command(op.name).description(op.description);
+    for (const param of op.params) {
+      const flag = `--${param.name} <value>`;
+      const desc = buildParamDesc(param.description, param.enum);
+      if (param.required) {
+        cmd.requiredOption(flag, desc);
+      } else {
+        cmd.option(flag, desc);
+      }
+    }
+    cmd.action(async (opts) => {
+      const pathParams = {};
+      const queryParams = {};
+      const bodyParams = {};
+      for (const param of op.params) {
+        const value = opts[param.name];
+        if (value === void 0) continue;
+        if (param.in === "path") {
+          pathParams[param.name] = value;
+        } else if (param.in === "query") {
+          queryParams[param.name] = value;
+        } else {
+          bodyParams[param.name] = coerceValue(value, param.type);
+        }
+      }
+      const { data } = await apiRequest(
+        op.method,
+        op.path,
+        pathParams,
+        queryParams,
+        bodyParams,
+        op.fixed_body
+      );
+      console.log(JSON.stringify(data, null, 2));
+    });
+  }
+}
+function buildParamDesc(desc, enumValues) {
+  if (!desc) return "";
+  if (enumValues?.length) {
+    return `${desc} [${enumValues.join("|")}]`;
+  }
+  return desc;
+}
+function coerceValue(value, type) {
+  if (type === "number") {
+    const n = Number(value);
+    return Number.isNaN(n) ? value : n;
+  }
+  if (type === "string[]") {
+    return value.split(",").map((s) => s.trim());
+  }
+  return value;
+}
+
+// src/index.ts
+var program = new Command();
+program.name("ai-todo").description("CLI for AI agents to interact with ai-todo").version("0.1.0");
+program.command("login").description("Authenticate with ai-todo via browser").option("--token <jwt>", "Directly provide a JWT token (for headless environments)").action(async (opts) => {
+  await login(opts.token);
+});
+program.command("logout").description("Clear stored credentials").action(() => {
+  clearCredentials();
+  console.log(JSON.stringify({ success: true, message: "Logged out" }));
+});
+program.command("whoami").description("Show current authenticated user").action(() => {
+  const creds = loadCredentials();
+  if (!creds) {
+    console.log(JSON.stringify({ error: "Not logged in. Run: ai-todo login" }));
+    process.exit(2);
+  }
+  console.log(JSON.stringify({
+    user_id: creds.user_id,
+    email: creds.email
+  }));
+});
+async function main() {
+  const authCommands = ["login", "logout", "whoami", "help", "--help", "-h", "--version", "-V"];
+  const firstArg = process.argv[2];
+  if (!firstArg || authCommands.includes(firstArg)) {
+    await program.parseAsync(process.argv);
+    return;
+  }
+  try {
+    const manifest = await fetchManifest();
+    registerDynamicCommands(program, manifest.operations);
+  } catch {
+    console.log(JSON.stringify({ error: "Failed to load commands from server" }));
+    process.exit(1);
+  }
+  await program.parseAsync(process.argv);
+}
+main().catch((err) => {
+  console.log(JSON.stringify({ error: err instanceof Error ? err.message : "Unknown error" }));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "ai-todo-cli",
+  "version": "0.1.0",
+  "description": "CLI tool for AI agents to interact with ai-todo",
+  "type": "module",
+  "bin": {
+    "ai-todo": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  },
+  "dependencies": {
+    "commander": "^13.0.0",
+    "open": "^10.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.9.0",
+    "@types/node": "^22.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT"
+}