@camox/cli 0.2.0-alpha.4

package/LICENSE.md

@@ -0,0 +1,110 @@
+# Functional Source License, Version 1.1, MIT Future License
+
+## Abbreviation
+
+FSL-1.1-MIT
+
+## Notice
+
+Copyright 2026 Rémi de Juvigny
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT license that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT license, in which case the following will apply:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/api-4OWBCL7B.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import {
+  createOrganization,
+  createProject,
+  listOrganizations,
+  setActiveOrganization,
+  verifySession
+} from "./chunk-KYDY3NNE.js";
+export {
+  createOrganization,
+  createProject,
+  listOrganizations,
+  setActiveOrganization,
+  verifySession
+};

package/dist/chunk-KYDY3NNE.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/api.ts
+import { createORPCClient } from "@orpc/client";
+import { RPCLink } from "@orpc/client/fetch";
+var CAMOX_API_URL = process.env.CAMOX_API_URL || "https://api.camox.ai";
+function authHeaders(token) {
+  return {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json"
+  };
+}
+function createRpcClient(token) {
+  const link = new RPCLink({
+    url: `${CAMOX_API_URL}/rpc`,
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  return createORPCClient(link);
+}
+async function verifySession(token) {
+  const res = await fetch(`${CAMOX_API_URL}/api/auth/get-session`, {
+    method: "GET",
+    headers: authHeaders(token)
+  });
+  return res.ok;
+}
+async function listOrganizations(token) {
+  const res = await fetch(`${CAMOX_API_URL}/api/auth/organization/list`, {
+    method: "GET",
+    headers: authHeaders(token)
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to list organizations: ${res.status}`);
+  }
+  return res.json();
+}
+async function createOrganization(token, name, slug) {
+  const res = await fetch(`${CAMOX_API_URL}/api/auth/organization/create`, {
+    method: "POST",
+    headers: authHeaders(token),
+    body: JSON.stringify({ name, slug })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Failed to create organization: ${res.status} ${text}`);
+  }
+  return res.json();
+}
+async function setActiveOrganization(token, organizationId) {
+  const res = await fetch(`${CAMOX_API_URL}/api/auth/organization/set-active`, {
+    method: "POST",
+    headers: authHeaders(token),
+    body: JSON.stringify({ organizationId })
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to set active organization: ${res.status}`);
+  }
+}
+async function createProject(token, name, organizationSlug) {
+  const client = createRpcClient(token);
+  const result = await client.projects.create({ name, organizationSlug });
+  return result;
+}
+
+export {
+  __export,
+  verifySession,
+  listOrganizations,
+  createOrganization,
+  setActiveOrganization,
+  createProject
+};

package/dist/index.js

@@ -0,0 +1,501 @@
+#!/usr/bin/env node
+import {
+  __export,
+  createOrganization,
+  createProject,
+  listOrganizations,
+  setActiveOrganization
+} from "./chunk-KYDY3NNE.js";
+
+// src/index.ts
+import { or } from "@optique/core/constructs";
+import { message } from "@optique/core/message";
+import { defineProgram } from "@optique/core/program";
+import { run } from "@optique/run";
+
+// src/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  handler: () => handler,
+  init: () => init,
+  parser: () => parser
+});
+import { execSync as execSync3, spawn, spawnSync } from "child_process";
+import fs3 from "fs";
+import path3 from "path";
+import { fileURLToPath } from "url";
+import * as p2 from "@clack/prompts";
+import { object } from "@optique/core/constructs";
+import { command, constant } from "@optique/core/primitives";
+
+// src/lib/auth.ts
+import { execSync } from "child_process";
+import fs from "fs";
+import http from "http";
+import os from "os";
+import path from "path";
+import * as p from "@clack/prompts";
+var CAMOX_URL = process.env.CAMOX_URL || "https://camox.ai";
+var CAMOX_API_URL = process.env.CAMOX_API_URL || "https://api.camox.ai";
+var AUTH_TIMEOUT_MS = 12e4;
+var AUTH_DIR = path.join(os.homedir(), ".camox");
+var AUTH_FILE = path.join(AUTH_DIR, "auth.json");
+function readAuthToken() {
+  try {
+    const data = JSON.parse(fs.readFileSync(AUTH_FILE, "utf-8"));
+    if (data?.token && data?.name) return data;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function writeAuthToken(token) {
+  fs.mkdirSync(AUTH_DIR, { recursive: true });
+  fs.writeFileSync(AUTH_FILE, JSON.stringify(token, null, 2), { mode: 384 });
+}
+function removeAuthToken() {
+  try {
+    fs.unlinkSync(AUTH_FILE);
+  } catch {
+  }
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try {
+    execSync(`${cmd} ${JSON.stringify(url)}`, { stdio: "ignore" });
+  } catch {
+  }
+}
+function startCallbackServer() {
+  return new Promise((resolve, reject) => {
+    let resolveOtt;
+    const ottPromise = new Promise((res) => {
+      resolveOtt = res;
+    });
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url ?? "/", `http://localhost`);
+      if (url.pathname !== "/callback") {
+        res.writeHead(404);
+        res.end();
+        return;
+      }
+      const ott = url.searchParams.get("ott");
+      if (!ott) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end("<html><body><h2>Missing token. Please try again.</h2></body></html>");
+        return;
+      }
+      res.writeHead(302, { Location: `${CAMOX_URL}/cli-authorized` });
+      res.end();
+      resolveOtt(ott);
+    });
+    server.listen(0, () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        reject(new Error("Failed to start callback server"));
+        return;
+      }
+      resolve({
+        port: addr.port,
+        ottPromise,
+        close: () => server.close()
+      });
+    });
+    server.on("error", reject);
+  });
+}
+async function verifyOtt(token) {
+  const res = await fetch(`${CAMOX_API_URL}/api/auth/one-time-token/verify`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ token })
+  });
+  if (!res.ok) {
+    throw new Error(`OTT verification failed: ${res.status}`);
+  }
+  const data = await res.json();
+  const user = data.user;
+  if (!user?.name) {
+    throw new Error("No user info in verification response");
+  }
+  const sessionToken = data.session?.token;
+  if (!sessionToken) {
+    throw new Error("No session token in verification response");
+  }
+  return { name: user.name, email: user.email ?? "", sessionToken };
+}
+async function authenticateUser() {
+  const { port, ottPromise, close } = await startCallbackServer();
+  const loginUrl = `${CAMOX_URL}/cli-authorize?callback=${encodeURIComponent(`http://localhost:${port}/callback`)}`;
+  const action = await p.select({
+    message: "Log in to Camox",
+    options: [
+      { value: "open", label: "Open browser" },
+      { value: "copy", label: "Copy URL" }
+    ]
+  });
+  if (p.isCancel(action)) {
+    close();
+    throw new Error("Authentication cancelled");
+  }
+  if (action === "open") {
+    openBrowser(loginUrl);
+  } else {
+    p.log.info(loginUrl);
+  }
+  const s = p.spinner();
+  s.start("Waiting for authentication...");
+  try {
+    const ott = await Promise.race([
+      ottPromise,
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("Authentication timed out")), AUTH_TIMEOUT_MS)
+      )
+    ]);
+    s.message("Verifying...");
+    const result2 = await verifyOtt(ott);
+    const authToken = {
+      token: result2.sessionToken,
+      name: result2.name,
+      email: result2.email
+    };
+    writeAuthToken(authToken);
+    s.stop(`Authenticated as ${result2.name}`);
+    return authToken;
+  } catch (err) {
+    s.stop("Authentication failed.");
+    throw err;
+  } finally {
+    close();
+  }
+}
+async function getOrAuthenticate() {
+  const stored = readAuthToken();
+  if (stored) {
+    const { verifySession } = await import("./api-4OWBCL7B.js");
+    const valid = await verifySession(stored.token);
+    if (valid) {
+      p.log.info(`Authenticated as ${stored.name}`);
+      return stored;
+    }
+    removeAuthToken();
+    p.log.warn("Session expired. Please log in again.");
+  } else {
+    p.log.info("Please authenticate to create a Camox project.");
+  }
+  return authenticateUser();
+}
+
+// src/lib/utils.ts
+import { execSync as execSync2 } from "child_process";
+import fs2 from "fs";
+import path2 from "path";
+var pmCommands = {
+  pnpm: { install: "pnpm install", dev: "pnpm dev" },
+  bun: { install: "bun install", dev: "bun dev" },
+  npm: { install: "npm install", dev: "npm run dev" },
+  yarn: { install: "yarn install", dev: "yarn dev" }
+};
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function detectPackageManager() {
+  const userAgent = process.env.npm_config_user_agent;
+  if (userAgent) {
+    const name = userAgent.split("/")[0];
+    if (name === "pnpm") return "pnpm";
+    if (name === "bun") return "bun";
+    if (name === "npm" || name === "npx") return "npm";
+    if (name === "yarn") return "yarn";
+  }
+  let dir = process.cwd();
+  const root = path2.parse(dir).root;
+  while (true) {
+    if (fs2.existsSync(path2.join(dir, "pnpm-lock.yaml")) || fs2.existsSync(path2.join(dir, "pnpm-workspace.yaml")))
+      return "pnpm";
+    if (fs2.existsSync(path2.join(dir, "bun.lockb")) || fs2.existsSync(path2.join(dir, "bun.lock")))
+      return "bun";
+    if (fs2.existsSync(path2.join(dir, "package-lock.json"))) return "npm";
+    if (fs2.existsSync(path2.join(dir, "yarn.lock"))) return "yarn";
+    if (dir === root) break;
+    dir = path2.dirname(dir);
+  }
+  return null;
+}
+function isInsideGitRepo() {
+  try {
+    execSync2("git rev-parse --is-inside-work-tree", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function copyDir(src, dest, replacements) {
+  fs2.mkdirSync(dest, { recursive: true });
+  for (const entry of fs2.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path2.join(src, entry.name);
+    const destPath = path2.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath, replacements);
+      continue;
+    }
+    let content = fs2.readFileSync(srcPath, "utf-8");
+    for (const [key, value] of Object.entries(replacements)) {
+      content = content.replaceAll(key, value);
+    }
+    fs2.writeFileSync(destPath, content);
+  }
+}
+
+// src/commands/init.ts
+var parser = command(
+  "init",
+  object({
+    command: constant("init")
+  })
+);
+var handler = init;
+var __dirname = path3.dirname(fileURLToPath(import.meta.url));
+var ownPkg = JSON.parse(fs3.readFileSync(path3.resolve(__dirname, "..", "package.json"), "utf-8"));
+function onCancel() {
+  p2.cancel("Cancelled.");
+  process.exit(0);
+}
+var CREATE_NEW_ORG = "__create_new__";
+async function selectOrCreateOrganization(token) {
+  const orgs = await listOrganizations(token);
+  if (orgs.length === 0) {
+    p2.log.info("You don't have any organizations yet. Let's create one.");
+    return promptCreateOrganization(token);
+  }
+  const selected = await p2.select({
+    message: "Select an organization for your new project",
+    options: [
+      ...orgs.map((org2) => ({ value: org2.id, label: `${org2.name} (${org2.slug})` })),
+      { value: CREATE_NEW_ORG, label: "Create a new organization" }
+    ]
+  });
+  if (p2.isCancel(selected)) return onCancel();
+  if (selected === CREATE_NEW_ORG) {
+    return promptCreateOrganization(token);
+  }
+  const org = orgs.find((o) => o.id === selected);
+  await setActiveOrganization(token, org.id);
+  return org.slug;
+}
+async function promptCreateOrganization(token) {
+  const orgName = await p2.text({
+    message: "Organization name",
+    placeholder: "My Company",
+    validate: (value) => {
+      if (!value.trim()) return "Organization name is required";
+    }
+  });
+  if (p2.isCancel(orgName)) return onCancel();
+  const orgSlug = slugify(orgName);
+  const org = await createOrganization(token, orgName, orgSlug);
+  p2.log.success(`Created organization: ${org.name}`);
+  return org.slug;
+}
+async function init() {
+  p2.intro("camox init");
+  const result2 = await p2.group(
+    {
+      name: () => p2.text({
+        message: "Project display name",
+        placeholder: "My Website",
+        validate: (value) => {
+          if (!value.trim()) return "Project name is required";
+        }
+      }),
+      path: ({ results }) => p2.text({
+        message: "Project path",
+        initialValue: `./${slugify(results.name ?? "") || "my-site"}`,
+        validate: (value) => {
+          if (!value.trim()) return "Path is required";
+        }
+      })
+    },
+    { onCancel }
+  );
+  const targetDir = path3.resolve(result2.path);
+  const auth = await getOrAuthenticate();
+  const orgSlug = await selectOrCreateOrganization(auth.token);
+  const s0 = p2.spinner();
+  s0.start("Creating project...");
+  let project;
+  try {
+    project = await createProject(auth.token, result2.name, orgSlug);
+    s0.stop(`Project created with slug: ${project.slug}`);
+  } catch (err) {
+    s0.stop("Failed to create project.");
+    p2.log.error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+  if (fs3.existsSync(targetDir) && fs3.readdirSync(targetDir).length > 0) {
+    p2.cancel(`Directory ${targetDir} is not empty.`);
+    process.exit(1);
+  }
+  const alreadyInRepo = isInsideGitRepo();
+  let initGit = false;
+  if (!alreadyInRepo) {
+    const answer = await p2.confirm({
+      message: "Initialize a git repository?",
+      initialValue: true
+    });
+    if (p2.isCancel(answer)) return onCancel();
+    initGit = answer;
+  }
+  const detected = detectPackageManager();
+  let pm;
+  if (detected) {
+    pm = detected;
+    p2.log.info(`Detected package manager: ${detected}`);
+  } else {
+    const selected = await p2.select({
+      message: "Which package manager?",
+      options: [
+        { value: "pnpm", label: "pnpm" },
+        { value: "bun", label: "bun" },
+        { value: "npm", label: "npm" },
+        { value: "yarn", label: "yarn" }
+      ]
+    });
+    if (p2.isCancel(selected)) return onCancel();
+    pm = selected;
+  }
+  const s = p2.spinner();
+  s.start("Scaffolding project...");
+  const templateDir = path3.resolve(__dirname, "..", "template");
+  copyDir(templateDir, targetDir, {
+    "{{projectName}}": result2.name,
+    "{{projectSlug}}": project.slug,
+    "{{syncSecret}}": project.syncSecret,
+    "{{camoxVersion}}": ownPkg.version
+  });
+  s.stop("Project scaffolded!");
+  function dropIntoProject() {
+    const shell = process.env.SHELL || "/bin/bash";
+    p2.log.info(`Dropping you into ${result2.path}`);
+    spawnSync(shell, [], { cwd: targetDir, stdio: "inherit" });
+    process.exit(0);
+  }
+  if (initGit) {
+    try {
+      execSync3("git init", { cwd: targetDir, stdio: "ignore" });
+      p2.log.success("Initialized git repository.");
+    } catch {
+      p2.log.warn("Could not initialize git repository.");
+    }
+  }
+  const { install: installCmd, dev: devCmd } = pmCommands[pm];
+  const [installBin, ...installArgs] = installCmd.split(" ");
+  const s2 = p2.spinner();
+  s2.start(`Running ${installCmd}...`);
+  try {
+    await new Promise((resolve, reject) => {
+      const child2 = spawn(installBin, installArgs, {
+        cwd: targetDir,
+        stdio: "ignore"
+      });
+      child2.on("close", (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(`Exit code ${code}`));
+      });
+      child2.on("error", reject);
+    });
+    s2.stop("Dependencies installed!");
+  } catch {
+    s2.stop("Install failed.");
+    p2.log.error(`Failed to install dependencies. Run "${installCmd}" manually.`);
+    dropIntoProject();
+  }
+  if (initGit) {
+    try {
+      execSync3("git add -A", { cwd: targetDir, stdio: "ignore" });
+      execSync3('git commit -m "Initial commit from camox init"', {
+        cwd: targetDir,
+        stdio: "ignore"
+      });
+      p2.log.success("Created initial commit.");
+    } catch {
+      p2.log.warn("Could not create initial commit.");
+    }
+  }
+  p2.outro(`Starting dev server...`);
+  const [cmd, ...args] = devCmd.split(" ");
+  const child = spawn(cmd, args, {
+    cwd: targetDir,
+    stdio: "inherit"
+  });
+  child.on("close", () => {
+    dropIntoProject();
+  });
+}
+
+// src/commands/login.ts
+var login_exports = {};
+__export(login_exports, {
+  handler: () => handler2,
+  login: () => login,
+  parser: () => parser2
+});
+import * as p3 from "@clack/prompts";
+import { object as object2 } from "@optique/core/constructs";
+import { command as command2, constant as constant2 } from "@optique/core/primitives";
+var parser2 = command2(
+  "login",
+  object2({
+    command: constant2("login")
+  })
+);
+var handler2 = login;
+async function login() {
+  p3.intro("camox login");
+  try {
+    await getOrAuthenticate();
+  } catch {
+    p3.log.error("Authentication failed.");
+    process.exit(1);
+  }
+  p3.outro("You're all set!");
+  process.exit(0);
+}
+
+// src/commands/logout.ts
+var logout_exports = {};
+__export(logout_exports, {
+  handler: () => handler3,
+  logout: () => logout,
+  parser: () => parser3
+});
+import { object as object3 } from "@optique/core/constructs";
+import { command as command3, constant as constant3 } from "@optique/core/primitives";
+var parser3 = command3(
+  "logout",
+  object3({
+    command: constant3("logout")
+  })
+);
+var handler3 = logout;
+function logout() {
+  const token = readAuthToken();
+  if (!token) {
+    console.log("Not logged in.");
+    return;
+  }
+  removeAuthToken();
+  console.log(`Logged out from ${token.name}.`);
+}
+
+// src/index.ts
+var commands = { init: init_exports, login: login_exports, logout: logout_exports };
+var program = defineProgram({
+  parser: or(parser, parser2, parser3),
+  metadata: {
+    name: "camox",
+    brief: message`Camox CLI`
+  }
+});
+var result = run(program, { help: "both" });
+await commands[result.command].handler();