@irtio/cli 0.5.0 → 0.5.2

package/dist/chunk-32QTPKVT.js

@@ -0,0 +1,93 @@
+import {
+  ApiClientError
+} from "./chunk-TV66QHFP.js";
+
+// src/project-file.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import * as path from "path";
+var DEFAULT_CONFIG_FILE = "irtio.json";
+function configPath(cwd, configFile) {
+  return path.resolve(cwd, configFile ?? DEFAULT_CONFIG_FILE);
+}
+async function readProjectConfig(cwd, command, configFile) {
+  const file = configPath(cwd, configFile);
+  if (!existsSync(file)) {
+    if (configFile !== void 0) throw new Error(`${command}: no config file at ${file}`);
+    return { file, exists: false };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(file, "utf8"));
+  } catch (err) {
+    throw new Error(`${command}: ${file} is not valid JSON: ${String(err)}`);
+  }
+  const raw = typeof parsed === "object" && parsed !== null ? parsed : {};
+  const str = (key) => {
+    const value = raw[key];
+    if (value === void 0) return void 0;
+    if (typeof value !== "string" || value.length === 0) {
+      throw new Error(`${command}: ${file} has a "${key}" that is not a non-empty string`);
+    }
+    return value;
+  };
+  const project = str("project");
+  const name = str("name");
+  const client = str("client");
+  const staticSite = readStatic(raw.static, file, command);
+  return {
+    file,
+    exists: true,
+    ...project !== void 0 ? { project } : {},
+    ...name !== void 0 ? { name } : {},
+    ...client !== void 0 ? { client } : {},
+    ...staticSite !== void 0 ? { static: staticSite } : {}
+  };
+}
+function readStatic(value, file, command) {
+  if (value === void 0) return void 0;
+  if (typeof value === "string") {
+    if (value.length === 0) {
+      throw new Error(`${command}: ${file} has a "static" that is an empty string`);
+    }
+    return { dir: value };
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(
+      `${command}: ${file} has a "static" that is neither a directory string nor an object`
+    );
+  }
+  const { dir, label } = value;
+  if (typeof dir !== "string" || dir.length === 0) {
+    throw new Error(`${command}: ${file} has a "static" with no "dir"`);
+  }
+  if (label !== void 0 && (typeof label !== "string" || label.length === 0)) {
+    throw new Error(`${command}: ${file} has a "static.label" that is not a non-empty string`);
+  }
+  return label === void 0 ? { dir } : { dir, label };
+}
+async function ensureProject(client, projectId, options) {
+  const config = options.config ?? await readProjectConfig(options.cwd, options.command);
+  const declared = options.name ?? config.name;
+  let existing;
+  try {
+    existing = await client.get(`/v1/projects/${projectId}`);
+  } catch (err) {
+    if (!(err instanceof ApiClientError && err.status === 404)) throw err;
+  }
+  if (existing === void 0) {
+    const name = declared ?? path.basename(options.cwd);
+    await client.post("/v1/projects", { name, id: projectId });
+    return { action: "created", name };
+  }
+  if (declared !== void 0 && declared !== existing.name) {
+    await client.patch(`/v1/projects/${projectId}`, { name: declared });
+    return { action: "renamed", name: declared, from: existing.name };
+  }
+  return { action: "unchanged", name: existing.name };
+}
+
+export {
+  readProjectConfig,
+  ensureProject
+};

package/dist/{static-deploy-LZXTDYNY.js → chunk-GBNHBWES.js}

@@ -3,27 +3,60 @@ import {
   staticPathProblem
 } from "./chunk-BPE452KF.js";
 import {
-  createApiClient,
-  isLoginRequired
-} from "./chunk-I37DLT7K.js";
+  ensureProject,
+  readProjectConfig
+} from "./chunk-32QTPKVT.js";
 import {
+  HelpRequested,
+  createApiClient,
+  helpFor,
+  helpRequested,
+  isLoginRequired,
   resolveControlUrlForUser
-} from "./chunk-NVUKSP5U.js";
+} from "./chunk-TV66QHFP.js";
 
 // src/static-deploy.ts
 import { existsSync } from "fs";
 import { lstat, readFile, readdir } from "fs/promises";
 import * as path from "path";
+import pc2 from "picocolors";
+
+// src/deploy-log.ts
 import pc from "picocolors";
+function logEnsured(log, projectId, ensured) {
+  if (ensured.action === "created") log(pc.dim(`created project ${projectId} (${ensured.name})`));
+  if (ensured.action === "renamed") {
+    log(pc.dim(`renamed project ${projectId}: ${ensured.from} -> ${ensured.name}`));
+  }
+}
+
+// src/static-deploy.ts
+var USAGE = `usage: irtio deploy --static [<dir>] [options]
+
+Uploads a BUILT client directory to the project's static site and prints the playable link. There
+is no build step: point it at the output your bundler already produced.
+
+options:
+  [<dir>]            the directory to upload (default: the project file's "static")
+  --label <label>    the site's hostname label (<label>.irt-serve.com)
+  --project <id>     project id (default: the project file)
+  --name <name>      the name a first deploy registers the project under
+  -c, --config <f>   the project file to read (default irtio.json)
+  --url <control>    control plane (default: your stored login)
+  -h, --help         print this
+`;
 function parseStaticDeployArgs(args) {
+  if (helpRequested(args)) throw helpFor(USAGE);
   const parsed = {};
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     switch (arg) {
       case "--static": {
-        const value = args[++i];
-        if (value === void 0) throw new Error("irtio deploy: --static needs a directory");
-        parsed.dir = value;
+        const value = args[i + 1];
+        if (value !== void 0 && !value.startsWith("-")) {
+          parsed.dir = value;
+          i++;
+        }
         break;
       }
       case "--project": {
@@ -44,11 +77,27 @@ function parseStaticDeployArgs(args) {
         parsed.label = value;
         break;
       }
+      case "--name": {
+        const value = args[++i];
+        if (value === void 0 || value === "") {
+          throw new Error("irtio deploy: --name needs a value");
+        }
+        parsed.name = value;
+        break;
+      }
+      case "-c":
+      case "--config": {
+        const value = args[++i];
+        if (value === void 0 || value === "") {
+          throw new Error("irtio deploy: --config needs a value");
+        }
+        parsed.config = value;
+        break;
+      }
       default:
         throw new Error(`irtio deploy --static: unknown option ${JSON.stringify(arg)}`);
     }
   }
-  if (parsed.dir === void 0) throw new Error("irtio deploy: --static needs a directory");
   return parsed;
 }
 async function walkStaticDir(dir) {
@@ -83,30 +132,27 @@ async function walkStaticDir(dir) {
   await walk(dir, "");
   return { files, skipped };
 }
-async function readIrtioJsonProject(cwd) {
-  const file = path.join(cwd, "irtio.json");
-  if (!existsSync(file)) return void 0;
-  let parsed;
-  try {
-    parsed = JSON.parse(await readFile(file, "utf8"));
-  } catch {
-    throw new Error(`irtio deploy: ${file} is not valid JSON`);
-  }
-  return typeof parsed.project === "string" && parsed.project.length > 0 ? parsed.project : void 0;
-}
 async function runStaticDeploy(options) {
   const log = options.log ?? ((line) => console.log(line));
   const cwd = path.resolve(options.cwd ?? process.cwd());
-  const dir = path.resolve(cwd, options.dir);
+  const config = await readProjectConfig(cwd, "irtio deploy", options.config);
+  const relativeDir = options.dir ?? config.static?.dir;
+  if (relativeDir === void 0) {
+    throw new Error(
+      `irtio deploy: no directory to upload \u2014 pass --static <dir> or add "static" to ${path.basename(config.file)}`
+    );
+  }
+  const dir = path.resolve(cwd, relativeDir);
   if (!existsSync(dir)) throw new Error(`irtio deploy: ${dir} does not exist`);
-  const project = options.project ?? await readIrtioJsonProject(cwd);
+  const project = options.project ?? config.project;
   if (project === void 0) {
     throw new Error(
-      "irtio deploy: no project id \u2014 pass --project or run from a project with irtio.json"
+      `irtio deploy: no project id \u2014 pass --project or run from a project with ${path.basename(config.file)}`
     );
   }
+  const label = options.label ?? config.static?.label;
   const { files, skipped } = await walkStaticDir(dir);
-  for (const line of skipped) log(pc.yellow(`skipped ${line}`));
+  for (const line of skipped) log(pc2.yellow(`skipped ${line}`));
   if (files.length === 0) throw new Error(`irtio deploy: ${dir} has no files to upload`);
   if (files.length > STATIC_LIMITS.maxFiles) {
     throw new Error(
@@ -127,14 +173,21 @@ async function runStaticDeploy(options) {
   }
   if (!files.some((f) => f.rel === "index.html")) {
     log(
-      pc.yellow("note: no index.html at the top level \u2014 the site link will 404 until one exists")
+      pc2.yellow("note: no index.html at the top level \u2014 the site link will 404 until one exists")
     );
   }
   const controlUrl = await resolveControlUrlForUser(options.controlUrl);
   const client = options.client ?? await createApiClient(controlUrl);
+  const ensured = await ensureProject(client, project, {
+    cwd,
+    config,
+    command: "irtio deploy",
+    ...options.name !== void 0 ? { name: options.name } : {}
+  });
+  logEnsured(log, project, ensured);
   const begin = await client.post(
     `/v1/projects/${project}/static/begin`,
-    options.label !== void 0 ? { label: options.label } : {}
+    label !== void 0 ? { label } : {}
   );
   for (const file of files) {
     const bytes = await readFile(file.abs);
@@ -149,13 +202,13 @@ async function runStaticDeploy(options) {
     label: begin.label
   });
   if (activated.url !== void 0) {
-    log(pc.green(`live: ${activated.url}`));
+    log(pc2.green(`live: ${activated.url}`));
     if (activated.origin !== void 0) {
-      log(pc.dim(`allowed origin: ${activated.origin} (localhost is always allowed)`));
+      log(pc2.dim(`allowed origin: ${activated.origin} (localhost is always allowed)`));
     }
   } else {
     log(
-      pc.green(
+      pc2.green(
         `activated ${activated.label} v${activated.version} (this control plane has no static domain configured; nothing serves it yet)`
       )
     );
@@ -176,28 +229,37 @@ async function staticDeploy(args, deps = {}) {
   try {
     const parsed = parseStaticDeployArgs(args);
     await runStaticDeploy({
-      dir: parsed.dir,
       log,
+      ...parsed.dir !== void 0 ? { dir: parsed.dir } : {},
       ...parsed.project !== void 0 ? { project: parsed.project } : {},
       ...parsed.url !== void 0 ? { controlUrl: parsed.url } : {},
       ...parsed.label !== void 0 ? { label: parsed.label } : {},
+      ...parsed.name !== void 0 ? { name: parsed.name } : {},
+      ...parsed.config !== void 0 ? { config: parsed.config } : {},
       ...deps.client !== void 0 ? { client: deps.client } : {},
       ...deps.cwd !== void 0 ? { cwd: deps.cwd } : {}
     });
   } catch (err) {
+    if (err instanceof HelpRequested) {
+      log(err.usage);
+      return;
+    }
     if (isLoginRequired(err)) {
-      errorLog(pc.red("not logged in"));
+      errorLog(pc2.red("not logged in"));
       errorLog("run: irtio login");
       process.exitCode = 1;
       return;
     }
-    errorLog(pc.red(err instanceof Error ? err.message : String(err)));
+    errorLog(pc2.red(err instanceof Error ? err.message : String(err)));
     process.exitCode = 1;
   }
 }
+
 export {
+  logEnsured,
+  USAGE,
   parseStaticDeployArgs,
+  walkStaticDir,
   runStaticDeploy,
-  staticDeploy,
-  walkStaticDir
+  staticDeploy
 };

package/dist/chunk-TV66QHFP.js

@@ -0,0 +1,167 @@
+// src/credentials.ts
+import { existsSync } from "fs";
+import { chmod, mkdir, readFile, writeFile } from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+function credentialsPath() {
+  if (process.env.IRT_CREDENTIALS_FILE) return process.env.IRT_CREDENTIALS_FILE;
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+    return path.join(appData, "irtio", "credentials.json");
+  }
+  return path.join(os.homedir(), ".config", "irtio", "credentials.json");
+}
+async function readCredentials() {
+  const file = credentialsPath();
+  if (!existsSync(file)) return {};
+  try {
+    const raw = await readFile(file, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+async function readCredential(controlUrl) {
+  const all = await readCredentials();
+  return all[controlUrl];
+}
+async function writeCredential(controlUrl, credential) {
+  const file = credentialsPath();
+  await mkdir(path.dirname(file), { recursive: true });
+  const all = await readCredentials();
+  all[controlUrl] = credential;
+  await writeFile(file, `${JSON.stringify(all, null, 2)}
+`, { mode: 384 });
+  await chmod(file, 384).catch(() => {
+  });
+  return file;
+}
+var DEFAULT_CONTROL_URL = "https://control.irt.io";
+function resolveControlUrl(flag) {
+  return flag ?? process.env.IRT_CONTROL_URL ?? DEFAULT_CONTROL_URL;
+}
+async function resolveControlUrlForUser(flag) {
+  const explicit = flag ?? process.env.IRT_CONTROL_URL;
+  if (explicit !== void 0) return explicit;
+  const all = await readCredentials();
+  const now = Date.now();
+  const live = Object.entries(all).filter(([, cred]) => new Date(cred.expiresAt).getTime() > now).map(([url]) => url);
+  const urls = live.length > 0 ? live : Object.keys(all);
+  return urls.length === 1 ? urls[0] : DEFAULT_CONTROL_URL;
+}
+
+// src/api-client.ts
+var ApiClientError = class extends Error {
+  name = "ApiClientError";
+  status;
+  code;
+  changes;
+  hint;
+  constructor(status, body) {
+    super(body.message);
+    this.status = status;
+    this.code = body.code;
+    this.changes = body.changes;
+    this.hint = body.hint;
+  }
+};
+var NotLoggedInError = class extends Error {
+  constructor(controlUrl) {
+    super(`not logged in to ${controlUrl} \u2014 run: irtio login`);
+    this.controlUrl = controlUrl;
+  }
+  controlUrl;
+  name = "NotLoggedInError";
+};
+async function createApiClient(controlUrl) {
+  const credential = await readCredential(controlUrl);
+  if (!credential) throw new NotLoggedInError(controlUrl);
+  return createApiClientWithToken(controlUrl, credential.token);
+}
+function createApiClientWithToken(controlUrl, token) {
+  async function request(method, path2, init = {}) {
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json"
+    };
+    let requestBody;
+    if (init.bytes !== void 0) {
+      headers["content-type"] = "application/octet-stream";
+      requestBody = init.bytes;
+    } else if (init.body !== void 0) {
+      headers["content-type"] = "application/json";
+      requestBody = JSON.stringify(init.body);
+    }
+    const response = await fetch(`${controlUrl}${path2}`, {
+      method,
+      headers,
+      ...requestBody !== void 0 ? { body: requestBody } : {}
+    });
+    const text = await response.text();
+    const parsed = text.length > 0 ? JSON.parse(text) : void 0;
+    if (!response.ok) {
+      const body = parsed !== void 0 && typeof parsed === "object" && parsed !== null && "code" in parsed && "message" in parsed ? parsed : {
+        code: "E_UNKNOWN",
+        message: text || `${method} ${path2} failed with ${response.status}`
+      };
+      throw new ApiClientError(response.status, body);
+    }
+    return parsed;
+  }
+  return {
+    controlUrl,
+    get(path2, query) {
+      const qs = query ? Object.entries(query).filter((e) => e[1] !== void 0).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&") : "";
+      return request("GET", qs ? `${path2}?${qs}` : path2);
+    },
+    post(path2, body) {
+      return request("POST", path2, { body });
+    },
+    patch(path2, body) {
+      return request("PATCH", path2, { body });
+    },
+    postBytes(path2, bytes) {
+      return request("POST", path2, { bytes });
+    }
+  };
+}
+function isLoginRequired(err) {
+  return err instanceof NotLoggedInError || err instanceof ApiClientError && err.status === 401;
+}
+
+// src/help.ts
+function helpRequested(args) {
+  return args.some((arg) => arg === "--help" || arg === "-h");
+}
+var HelpRequested = class extends Error {
+  constructor(usage) {
+    super(usage);
+    this.usage = usage;
+  }
+  usage;
+  name = "HelpRequested";
+};
+function helpFor(usage) {
+  return new HelpRequested(usage);
+}
+function trailerFor(err, hints = []) {
+  if (err instanceof ApiClientError && err.hint !== void 0 && err.hint !== "") return err.hint;
+  const grounded = hints.filter((h) => h !== "");
+  return grounded.length > 0 ? grounded.join("\n") : void 0;
+}
+
+export {
+  credentialsPath,
+  writeCredential,
+  resolveControlUrl,
+  resolveControlUrlForUser,
+  ApiClientError,
+  createApiClient,
+  isLoginRequired,
+  helpRequested,
+  HelpRequested,
+  helpFor,
+  trailerFor
+};