@cordfuse/crosstalk 7.0.0-alpha.4 → 7.0.0-alpha.6

package/lib/resolve.js

@@ -0,0 +1,181 @@
+// resolve.js — name-based resolution for the runtime-owned-transport
+// model (alpha.6+).
+//
+// Operator addresses transports by container name, picked at `crosstalk
+// init`. Default container is literally `crosstalk`; named containers
+// are literally whatever the operator typed into --containername.
+// Identity lives with the container; storage lives at <base>/<name>/.
+//
+// Replaces the cwd-walking transport.js from alpha.5 (which derived
+// identity from the operator's filesystem position). The new model is
+// position-independent — operator can be anywhere on disk.
+
+import { existsSync, readFileSync, mkdirSync, readdirSync } from 'fs';
+import { spawnSync } from 'child_process';
+import { join } from 'path';
+import { homedir } from 'os';
+
+export const DEFAULT_CONTAINER_NAME = 'crosstalk';
+export const DEFAULT_API_PORT = 7000;
+export const CROSSTALK_LABEL = 'crosstalk.transport=true';
+
+// Per-OS storage bases. User-mode (default) keeps everything under the
+// operator's home — no sudo/UAC, no Docker Desktop file-sharing allowlist
+// gymnastics. System-mode is for headless multi-operator deployments.
+export function resolveBase(mode) {
+  const platform = process.platform;
+  const bases = (platform === 'darwin')
+    ? {
+        user:   join(homedir(), 'Library', 'Application Support', 'crosstalk'),
+        system: '/Library/Application Support/crosstalk',
+      }
+    : (platform === 'win32')
+    ? {
+        user:   process.env['LOCALAPPDATA']
+                  ? join(process.env['LOCALAPPDATA'], 'crosstalk')
+                  : join(homedir(), 'AppData', 'Local', 'crosstalk'),
+        system: 'C:\\ProgramData\\crosstalk',
+      }
+    : {
+        user:   join(process.env['XDG_DATA_HOME'] ?? join(homedir(), '.local', 'share'), 'crosstalk'),
+        system: '/var/lib/crosstalk',
+      };
+
+  if (mode !== 'user' && mode !== 'system') {
+    throw new Error(`CROSSTALK_STORAGE_MODE='${mode}' invalid — must be 'user' or 'system'.`);
+  }
+  return bases[mode];
+}
+
+export function storageMode() {
+  return (process.env.CROSSTALK_STORAGE_MODE ?? 'user').toLowerCase();
+}
+
+// All storage paths for a given container name, derived from the resolved
+// base. None of these are validated for existence here — callers check
+// based on context (init pre-creates, up verifies, etc).
+export function storagePaths(name, mode = storageMode()) {
+  const base = resolveBase(mode);
+  const root = join(base, name);
+  return {
+    base,
+    mode,
+    storageRoot:    root,
+    transportDir:   join(root, 'transport'),
+    crosstalkRoot:  join(root, 'crosstalk-root'),
+    crosstalkState: join(root, 'crosstalk-state'),
+    composeFile:    join(root, 'docker-compose.yml'),
+    portFile:       join(root, 'api-port'),
+  };
+}
+
+// Container name from --containername flag, defaulting to `crosstalk`.
+// Validates the name is a sane Docker container name + filesystem dir
+// name: lowercase alphanumeric, `_.-`, no leading dot/hyphen.
+const NAME_RE = /^[a-z0-9][a-z0-9_.-]*$/;
+export function parseContainerName(argv) {
+  let name = DEFAULT_CONTAINER_NAME;
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--containername' || argv[i] === '-c') {
+      const val = argv[i + 1];
+      if (!val) throw new Error('--containername requires a value');
+      name = val;
+      break;
+    }
+  }
+  if (!NAME_RE.test(name)) {
+    throw new Error(
+      `--containername '${name}' invalid — must be lowercase alphanumeric ` +
+      `with optional ._- (no leading . or -).`,
+    );
+  }
+  return name;
+}
+
+// Read the API port for a given container. Source-of-truth lookup:
+//   1. `<base>/<name>/api-port` file (written at init time)
+//   2. Fallback: DEFAULT_API_PORT
+// We use a file rather than `docker inspect` because the resolver runs
+// before the container exists (`init`) and after it's gone (`rm` cleanup).
+// Docker is authoritative for what's running; the port file is
+// authoritative for which port a given container WOULD use.
+export function apiPortFor(name) {
+  const paths = storagePaths(name);
+  if (existsSync(paths.portFile)) {
+    const v = Number(readFileSync(paths.portFile, 'utf-8').trim());
+    if (Number.isInteger(v) && v > 0 && v < 65536) return v;
+  }
+  return DEFAULT_API_PORT;
+}
+
+// Pick a free TCP port. Default container always gets DEFAULT_API_PORT
+// (7000) so operators have a predictable target. Named containers search
+// upward from 7001 until they find one that doesn't collide with already-
+// allocated containers (any `<base>/*/api-port` file).
+export function pickFreePort(name, mode = storageMode()) {
+  if (name === DEFAULT_CONTAINER_NAME) return DEFAULT_API_PORT;
+  const base = resolveBase(mode);
+  const taken = new Set([DEFAULT_API_PORT]);
+  try {
+    const dirs = readdirSync(base);
+    for (const d of dirs) {
+      const portFile = join(base, d, 'api-port');
+      if (existsSync(portFile)) {
+        const v = Number(readFileSync(portFile, 'utf-8').trim());
+        if (Number.isInteger(v)) taken.add(v);
+      }
+    }
+  } catch { /* base may not exist yet */ }
+  for (let p = 7001; p < 8000; p++) {
+    if (!taken.has(p)) return p;
+  }
+  throw new Error('Could not find a free port between 7001 and 7999.');
+}
+
+// True if `<base>/<name>/transport/.git` exists. The cheapest signal that
+// a transport has been initialized for this name.
+export function isInitialized(name) {
+  const paths = storagePaths(name);
+  return existsSync(join(paths.transportDir, '.git'));
+}
+
+// True if a running container exists for this name. Uses Docker as the
+// source of truth, filtered by our label to avoid confusing
+// operator-named-`crosstalk` containers from other workloads.
+export function isRunning(name) {
+  const r = spawnSync(
+    'docker',
+    ['ps', '--filter', `label=${CROSSTALK_LABEL}`, '--filter', `name=^${name}$`, '--format', '{{.Names}}'],
+    { encoding: 'utf-8' },
+  );
+  if (r.status !== 0) return false;
+  return r.stdout.trim().split('\n').includes(name);
+}
+
+// True if a stopped container exists (less common path; usually `down`
+// removes the container). Checked separately so `up` can decide whether
+// to `docker rm` and recreate.
+export function containerExists(name) {
+  const r = spawnSync(
+    'docker',
+    ['ps', '-a', '--filter', `label=${CROSSTALK_LABEL}`, '--filter', `name=^${name}$`, '--format', '{{.Names}}'],
+    { encoding: 'utf-8' },
+  );
+  if (r.status !== 0) return false;
+  return r.stdout.trim().split('\n').includes(name);
+}
+
+// Look up the resolved name+paths from argv, validate that init has run,
+// and exit with a clear error if not. For verbs that operate on existing
+// transports (up after init, status, chat, down, rm, etc).
+export function requireInitialized(argv) {
+  const name = parseContainerName(argv);
+  if (!isInitialized(name)) {
+    process.stderr.write(
+      `crosstalk: no transport '${name}' on this machine.\n` +
+      `  Run 'crosstalk init${name === DEFAULT_CONTAINER_NAME ? '' : ` --containername ${name}`}' to set one up.\n`,
+    );
+    process.exit(2);
+  }
+  return { name, paths: storagePaths(name) };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cordfuse/crosstalk",
-  "version": "7.0.0-alpha.4",
+  "version": "7.0.0-alpha.6",
   "description": "Crosstalk client — host-side CLI that talks to the crosstalkd daemon running inside the crosstalk-server container.",
   "type": "module",
   "license": "MIT",

package/lib/transport.js

@@ -1,51 +0,0 @@
-// transport.js — locate the current Crosstalk transport on the host,
-// derive its conventional names (compose project, container name, etc.).
-//
-// A transport is identified by a CROSSTALK-VERSION file at its root.
-// `crosstalk` walks up from the operator's cwd to find it — same pattern
-// as `git`, `npm`, etc. discovering their root directories.
-
-import { existsSync, statSync } from 'fs';
-import { resolve, basename, dirname, join } from 'path';
-
-export function findTransportRoot(startDir = process.cwd()) {
-  let dir = resolve(startDir);
-  for (;;) {
-    if (existsSync(join(dir, 'CROSSTALK-VERSION'))) {
-      try {
-        if (statSync(join(dir, 'CROSSTALK-VERSION')).isFile()) return dir;
-      } catch { /* fall through */ }
-    }
-    const parent = dirname(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-}
-
-export function requireTransportRoot(startDir = process.cwd()) {
-  const root = findTransportRoot(startDir);
-  if (!root) {
-    process.stderr.write(
-      `crosstalk: not inside a Crosstalk transport ` +
-      `(no CROSSTALK-VERSION found from ${resolve(startDir)} upward).\n` +
-      `Create one with 'crosstalk init <dir>' or cd into an existing transport.\n`,
-    );
-    process.exit(2);
-  }
-  return root;
-}
-
-// transport-name is the basename of the transport root. Used for the
-// compose project, container name, volume names — gives each transport
-// on a host distinct docker objects without an explicit registry.
-export function transportName(transportRoot) {
-  return basename(transportRoot);
-}
-
-export function containerName(transportRoot) {
-  return `crosstalk-${transportName(transportRoot)}`;
-}
-
-export function composeFile(transportRoot) {
-  return join(transportRoot, 'docker-compose.yml');
-}