@awak-app/simy-cli 0.1.0 → 0.1.2

package/src/session-store.js

@@ -1,21 +1,55 @@
+import { createHash } from "node:crypto";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 
-const SESSION_PATH = join(homedir(), ".simy", "session.json");
+import { normalizeWebOrigin } from "./web-origin.js";
+
 const SESSION_TTL_MS = 48 * 60 * 60 * 1000;
 
-export function sessionPath() {
-  return SESSION_PATH;
+export function sessionPath(webOrigin, sessionRoot = defaultSessionRoot()) {
+  const origin = normalizeWebOrigin(webOrigin);
+  const originHash = createHash("sha256").update(origin).digest("hex");
+  return join(sessionRoot, "sessions", `${originHash}.json`);
 }
 
 export function expiresAtFromNow(now = Date.now()) {
   return new Date(now + SESSION_TTL_MS).toISOString();
 }
 
-export async function readSession() {
+export async function readSession(webOrigin, sessionRoot = defaultSessionRoot()) {
+  const origin = normalizeWebOrigin(webOrigin);
+  const scoped = await readSessionFile(sessionPath(origin, sessionRoot));
+  if (sessionMatchesOrigin(scoped, origin)) return scoped;
+
+  const legacy = await readSessionFile(join(sessionRoot, "session.json"));
+  return sessionMatchesOrigin(legacy, origin) ? legacy : null;
+}
+
+export function isSessionValid(session, now = Date.now(), webOrigin = null) {
+  if (!session?.expires_at) return false;
+  if (webOrigin && !sessionMatchesOrigin(session, normalizeWebOrigin(webOrigin))) return false;
+  const expiresAt = Date.parse(session.expires_at);
+  return Number.isFinite(expiresAt) && expiresAt > now;
+}
+
+export async function writeSession(webOrigin, session, sessionRoot = defaultSessionRoot()) {
+  const origin = normalizeWebOrigin(webOrigin);
+  const targetPath = sessionPath(origin, sessionRoot);
+  await mkdir(dirname(targetPath), { recursive: true, mode: 0o700 });
+  await writeFile(targetPath, `${JSON.stringify({ ...session, api_origin: origin }, null, 2)}\n`, {
+    encoding: "utf8",
+    mode: 0o600,
+  });
+}
+
+function defaultSessionRoot() {
+  return process.env.SIMY_HOME?.trim() || join(homedir(), ".simy");
+}
+
+async function readSessionFile(path) {
   try {
-    const raw = await readFile(SESSION_PATH, "utf8");
+    const raw = await readFile(path, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") return null;
     if (typeof parsed.token !== "string" || typeof parsed.expires_at !== "string") return null;
@@ -26,16 +60,11 @@ export async function readSession() {
   }
 }
 
-export function isSessionValid(session, now = Date.now()) {
-  if (!session?.expires_at) return false;
-  const expiresAt = Date.parse(session.expires_at);
-  return Number.isFinite(expiresAt) && expiresAt > now;
-}
-
-export async function writeSession(session) {
-  await mkdir(dirname(SESSION_PATH), { recursive: true, mode: 0o700 });
-  await writeFile(SESSION_PATH, `${JSON.stringify(session, null, 2)}\n`, {
-    encoding: "utf8",
-    mode: 0o600,
-  });
+function sessionMatchesOrigin(session, origin) {
+  if (typeof session?.api_origin !== "string") return false;
+  try {
+    return normalizeWebOrigin(session.api_origin) === origin;
+  } catch {
+    return false;
+  }
 }

package/src/web-api.js

@@ -0,0 +1,66 @@
+export function webApiHeaders({ token } = {}, extraHeaders = {}) {
+  const headers = { ...extraHeaders };
+  if (typeof token === "string" && token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+  return headers;
+}
+
+const APP_DEV_ORIGIN = "https://app-dev.simy.one";
+const APP_DEV_GATEWAY_BASE_URL = "https://app.simy.one/api/local-cli-gateway/";
+
+export function resolveWebApiBaseUrl(webOrigin, requestedBaseUrl = null) {
+  const normalizedWebOrigin = new URL(webOrigin).origin;
+  if (!requestedBaseUrl) {
+    if (normalizedWebOrigin === APP_DEV_ORIGIN) {
+      throw new Error("SIMY Web did not provide the required dev CLI gateway.");
+    }
+    return new URL("/api/local-cli/", normalizedWebOrigin).href;
+  }
+
+  const requested = new URL(requestedBaseUrl);
+  requested.hash = "";
+  requested.search = "";
+  if (!requested.pathname.endsWith("/")) requested.pathname += "/";
+
+  const directBase = new URL("/api/local-cli/", normalizedWebOrigin).href;
+  if (requested.href === directBase) return directBase;
+  if (
+    normalizedWebOrigin === APP_DEV_ORIGIN &&
+    requested.href === APP_DEV_GATEWAY_BASE_URL
+  ) {
+    return APP_DEV_GATEWAY_BASE_URL;
+  }
+  throw new Error("SIMY Web provided an untrusted CLI API endpoint.");
+}
+
+export function webApiUrl(path, { webOrigin, apiBaseUrl = null }) {
+  const baseUrl = resolveWebApiBaseUrl(webOrigin, apiBaseUrl);
+  return new URL(String(path || "").replace(/^\/+/, ""), baseUrl);
+}
+
+export function sessionRequiresWebAuthorization(session, webOrigin) {
+  try {
+    resolveWebApiBaseUrl(webOrigin, session?.api_base_url);
+    return false;
+  } catch {
+    return true;
+  }
+}
+
+export function webApiErrorMessage(payload, status) {
+  const message = nestedErrorMessage(payload);
+  return message || `SIMY Web returned HTTP ${status}.`;
+}
+
+function nestedErrorMessage(value, seen = new Set()) {
+  if (typeof value === "string") return value.trim();
+  if (!value || typeof value !== "object" || seen.has(value)) return "";
+  seen.add(value);
+
+  for (const key of ["message", "detail", "error", "hint", "description"]) {
+    const message = nestedErrorMessage(value[key], seen);
+    if (message) return message;
+  }
+  return "";
+}

package/src/web-origin.js

@@ -0,0 +1,46 @@
+export const DEFAULT_WEB_ORIGIN = "https://app.simy.one";
+
+export function resolveWebOrigin(host, env = process.env) {
+  return normalizeWebOrigin(
+    host || env.SIMY_WEB_ORIGIN || env.SIMY_API_ORIGIN || DEFAULT_WEB_ORIGIN,
+  );
+}
+
+export function normalizeWebOrigin(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("SIMY Web host must be an absolute http(s) URL.");
+  }
+
+  let url;
+  try {
+    url = new URL(value.trim());
+  } catch {
+    throw new Error("SIMY Web host must be an absolute http(s) URL.");
+  }
+
+  if (!["http:", "https:"].includes(url.protocol)) {
+    throw new Error("SIMY Web host must use http or https.");
+  }
+  if (url.username || url.password) {
+    throw new Error("SIMY Web host must not contain credentials.");
+  }
+  if ((url.pathname && url.pathname !== "/") || url.search || url.hash) {
+    throw new Error("SIMY Web host must contain only an origin, without a path or query.");
+  }
+
+  const loopbackHosts = new Set(["localhost", "127.0.0.1", "[::1]"]);
+  if (url.protocol === "http:" && !loopbackHosts.has(url.hostname)) {
+    throw new Error("SIMY Web host must use https unless it is a loopback address.");
+  }
+
+  return url.origin;
+}
+
+export function isRequestOriginAllowed(requestOrigin, webOrigin) {
+  if (!requestOrigin) return true;
+  try {
+    return normalizeWebOrigin(requestOrigin) === webOrigin;
+  } catch {
+    return false;
+  }
+}

package/src/workspace-context.js

@@ -0,0 +1,37 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+export async function discoverWorkspace(cwd = process.cwd()) {
+  try {
+    const [{ stdout: root }, { stdout: remote }, { stdout: branch }] = await Promise.all([
+      execFileAsync("git", ["rev-parse", "--show-toplevel"], { cwd }),
+      execFileAsync("git", ["remote", "get-url", "origin"], { cwd }),
+      execFileAsync("git", ["branch", "--show-current"], { cwd }),
+    ]);
+    const repository = normalizeGitHubRemote(remote);
+    if (!repository) return emptyWorkspace(cwd);
+    return {
+      repository,
+      branch: String(branch || "").trim() || "dev",
+      localPath: String(root || "").trim(),
+    };
+  } catch {
+    return emptyWorkspace(cwd);
+  }
+}
+
+export function normalizeGitHubRemote(value) {
+  const repository = String(value || "")
+    .trim()
+    .replace(/^git@github\.com:/, "")
+    .replace(/^ssh:\/\/git@github\.com\//, "")
+    .replace(/^https?:\/\/github\.com\//, "")
+    .replace(/\.git$/, "");
+  return repository.includes("/") ? repository : null;
+}
+
+function emptyWorkspace(cwd) {
+  return { repository: null, branch: "dev", localPath: cwd };
+}