@tryarcanist/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/api.ts
+async function apiFetch(config, path, init) {
+  const res = await fetch(`${config.apiUrl}${path}`, {
+    ...init,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.token}`,
+      ...init?.headers
+    }
+  });
+  if (res.status === 401) {
+    throw new Error("Token is invalid or expired. Run `arcanist login` to re-authenticate.");
+  }
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`API error ${res.status}: ${body}`);
+  }
+  return res.json();
+}
+
+// src/config.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".arcanist");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+function loadConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+}
+function requireConfig() {
+  const config = loadConfig();
+  if (!config) {
+    console.error("Error: Not logged in. Run `arcanist login` first.");
+    process.exit(1);
+  }
+  return config;
+}
+function validateApiUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return "Invalid URL format";
+  }
+  const host = parsed.hostname.replace(/^\[|\]$/g, "");
+  const isLocal = host === "localhost" || host === "127.0.0.1" || host === "::1";
+  if (parsed.protocol !== "https:" && !isLocal) {
+    return "API URL must use HTTPS for non-local hosts";
+  }
+  return null;
+}
+
+// src/commands/create.ts
+async function createCommand(repoUrl, prompt, options) {
+  const config = requireConfig();
+  let sessionId;
+  try {
+    const sessionData = await apiFetch(config, "/api/sessions", {
+      method: "POST",
+      body: JSON.stringify({
+        context: { repoUrl },
+        ...options.model ? { model: options.model } : {}
+      })
+    });
+    sessionId = sessionData.sessionId;
+  } catch (err) {
+    console.error(`Error creating session: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  try {
+    await apiFetch(config, `/api/sessions/${sessionId}/prompts`, {
+      method: "POST",
+      body: JSON.stringify({ prompt })
+    });
+  } catch (err) {
+    console.error(`Session created (${sessionId}) but prompt failed: ${err instanceof Error ? err.message : String(err)}`);
+    console.error(`Retry with: arcanist message ${sessionId} "${prompt}"`);
+    process.exit(1);
+  }
+  const uiUrl = config.apiUrl.replace(/:\d+$/, ":5173");
+  console.log(`Session: ${sessionId}`);
+  console.log(`URL: ${uiUrl}/sessions/${sessionId}`);
+}
+
+// src/commands/login.ts
+import { createInterface } from "readline";
+async function loginCommand(options) {
+  let token;
+  if (options.tokenStdin) {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    token = Buffer.concat(chunks).toString().trim();
+  } else {
+    token = await promptHidden("Enter your CLI token: ");
+  }
+  if (!token) {
+    console.error("Error: No token provided.");
+    process.exit(1);
+  }
+  if (!token.startsWith("arc_")) {
+    console.error("Error: Invalid token format. Token must start with 'arc_'.");
+    process.exit(1);
+  }
+  const apiUrl = options.apiUrl ?? loadConfig()?.apiUrl ?? "https://app.tryarcanist.com";
+  if (options.apiUrl) {
+    const urlError = validateApiUrl(options.apiUrl);
+    if (urlError) {
+      console.error(`Error: ${urlError}`);
+      process.exit(1);
+    }
+  }
+  saveConfig({ apiUrl, token });
+  console.log(`Logged in. API: ${apiUrl}`);
+  try {
+    const res = await fetch(`${apiUrl}/api/cli-tokens`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (res.ok) {
+      console.log("Token verified.");
+    } else if (res.status === 401) {
+      console.warn("Warning: Token could not be verified (401). It may be invalid or expired.");
+    }
+  } catch {
+    console.warn("Warning: Could not reach API to verify token.");
+  }
+}
+function promptHidden(prompt) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    process.stdout.write(prompt);
+    const stdin = process.stdin;
+    if (stdin.isTTY) stdin.setRawMode(true);
+    let input = "";
+    const onData = (char) => {
+      const c = char.toString();
+      if (c === "\n" || c === "\r") {
+        if (stdin.isTTY) stdin.setRawMode(false);
+        stdin.removeListener("data", onData);
+        process.stdout.write("\n");
+        rl.close();
+        resolve(input);
+      } else if (c === "") {
+        if (stdin.isTTY) stdin.setRawMode(false);
+        process.exit(1);
+      } else if (c === "\x7F" || c === "\b") {
+        input = input.slice(0, -1);
+      } else {
+        input += c;
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+
+// src/commands/message.ts
+async function messageCommand(sessionId, prompt) {
+  const config = requireConfig();
+  try {
+    await apiFetch(config, `/api/sessions/${sessionId}/prompts`, {
+      method: "POST",
+      body: JSON.stringify({ prompt })
+    });
+    console.log(`Message sent to session ${sessionId}.`);
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var program = new Command().name("arcanist").description("Arcanist CLI").version("0.1.0");
+program.command("login").description("Authenticate with a personal access token").option("--token-stdin", "Read token from stdin instead of interactive prompt").option("--api-url <url>", "Set custom API URL").action(loginCommand);
+program.command("create").description("Create a session and send a prompt").argument("<repo-url>", "Repository URL").argument("<prompt>", "Prompt to send").option("--model <model>", "Model to use").action(createCommand);
+program.command("message").description("Send a message to an existing session").argument("<session-id>", "Session ID").argument("<prompt>", "Message to send").action(messageCommand);
+async function main() {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : "An unexpected error occurred."}`);
+    process.exit(1);
+  }
+}
+main();

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@tryarcanist/cli",
+  "version": "0.1.0",
+  "description": "CLI for Arcanist — create and manage coding agent sessions",
+  "type": "module",
+  "bin": {
+    "arcanist": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "prepublishOnly": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tryarcanist/arcanist",
+    "directory": "apps/cli"
+  },
+  "homepage": "https://www.tryarcanist.com",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0"
+  }
+}