@sentropic/remote-cli 0.0.3

package/dist/attach-YI2AMS3B.js

@@ -0,0 +1,22 @@
+import {
+  attach,
+  createRemoteSession,
+  getRemoteSession,
+  listRemoteSessions,
+  refreshRemoteSession,
+  renameRemoteSession,
+  sessionTerminalHealth,
+  stopRemoteSession
+} from "./chunk-VRTZ23J3.js";
+import "./chunk-E3GXAKJ3.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  attach,
+  createRemoteSession,
+  getRemoteSession,
+  listRemoteSessions,
+  refreshRemoteSession,
+  renameRemoteSession,
+  sessionTerminalHealth,
+  stopRemoteSession
+};

package/dist/chunk-3RG5ZIWI.js

@@ -0,0 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/chunk-E3GXAKJ3.js

@@ -0,0 +1,258 @@
+// src/config.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+var DEFAULT_LAYOUT = {
+  maxAgeHours: 48,
+  maxPerWindow: 12,
+  sharedWindows: 2,
+  multiSession: {},
+  groups: []
+};
+var DEFAULT_H2A_COMMAND = "h2a mcp-serve --auto-open --auto-upgrade --wake local-tmux";
+var DEFAULT_SESSION_TARGET = "scaleway-kapsule";
+function parseTunnel(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const t = raw;
+  if (typeof t.namespace !== "string" || typeof t.service !== "string" || typeof t.localPort !== "number" || typeof t.remotePort !== "number") {
+    return void 0;
+  }
+  const tunnel = {
+    namespace: t.namespace,
+    service: t.service,
+    localPort: t.localPort,
+    remotePort: t.remotePort
+  };
+  if (typeof t.kubeconfig === "string") tunnel.kubeconfig = t.kubeconfig;
+  return tunnel;
+}
+function parseH2a(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const h = raw;
+  const h2a = {};
+  if (typeof h.enabled === "boolean") h2a.enabled = h.enabled;
+  if (typeof h.command === "string") h2a.command = h.command;
+  return Object.keys(h2a).length > 0 ? h2a : void 0;
+}
+function parseLlmMeshRuntime(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const r = raw;
+  const llmMesh = {};
+  if (typeof r.enabled === "boolean") llmMesh.enabled = r.enabled;
+  return Object.keys(llmMesh).length > 0 ? llmMesh : void 0;
+}
+function parsePluginMcp(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const m = raw;
+  if (typeof m.name !== "string" || typeof m.command !== "string" || !Array.isArray(m.args) || !m.args.every((a) => typeof a === "string")) {
+    return void 0;
+  }
+  const mcp = {
+    name: m.name,
+    command: m.command,
+    args: m.args
+  };
+  if (typeof m.scriptRel === "string") mcp.scriptRel = m.scriptRel;
+  return mcp;
+}
+function parsePlugins(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const plugins = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object") continue;
+    const p = item;
+    if (typeof p.pkg !== "string" || typeof p.version !== "string" || !Array.isArray(p.mcp)) {
+      continue;
+    }
+    const mcp = p.mcp.map(parsePluginMcp).filter((m) => m !== void 0);
+    const entry = { pkg: p.pkg, version: p.version, mcp };
+    const install = parsePluginInstall(p.install);
+    if (install) entry.install = install;
+    plugins.push(entry);
+  }
+  return plugins;
+}
+function parsePluginInstall(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const i = raw;
+  if (i.method !== "npm" && i.method !== "curl" && i.method !== "script") {
+    return void 0;
+  }
+  const install = { method: i.method };
+  if (typeof i.spec === "string") install.spec = i.spec;
+  return install;
+}
+function configHome() {
+  return process.env.REMOTE_CLI_CONFIG_HOME ?? homedir();
+}
+function resolveConfigPath() {
+  return join(configHome(), ".config", "sentropic", "remote-cli", "config.json");
+}
+function normalizeRemoteUrl(rawUrl) {
+  const trimmed = rawUrl.trim();
+  if (!trimmed) {
+    throw new Error("Remote URL cannot be empty.");
+  }
+  const parsed = new URL(trimmed);
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(
+      `Unsupported remote URL protocol "${parsed.protocol}". Use http:// or https://.`
+    );
+  }
+  return trimmed.replace(/\/+$/, "");
+}
+function readRemoteConfig() {
+  try {
+    const raw = readFileSync(resolveConfigPath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") {
+      const config = {};
+      if (typeof parsed.defaultRemote === "string")
+        config.defaultRemote = parsed.defaultRemote;
+      if (typeof parsed.token === "string") config.token = parsed.token;
+      if (typeof parsed.defaultTarget === "string")
+        config.defaultTarget = parsed.defaultTarget;
+      if (Array.isArray(parsed.defaultTools) && parsed.defaultTools.every((t) => typeof t === "string")) {
+        config.defaultTools = parsed.defaultTools;
+      }
+      const tunnel = parseTunnel(parsed.tunnel);
+      if (tunnel) config.tunnel = tunnel;
+      if (parsed.layout && typeof parsed.layout === "object")
+        config.layout = parsed.layout;
+      const plugins = parsePlugins(parsed.plugins);
+      if (plugins) config.plugins = plugins;
+      const h2a = parseH2a(parsed.h2a);
+      if (h2a) config.h2a = h2a;
+      const llmMesh = parseLlmMeshRuntime(parsed.llmMesh);
+      if (llmMesh) config.llmMesh = llmMesh;
+      if (typeof parsed.maxConcurrent === "number" && Number.isFinite(parsed.maxConcurrent) && parsed.maxConcurrent > 0) {
+        config.maxConcurrent = Math.trunc(parsed.maxConcurrent);
+      }
+      return config;
+    }
+    return {};
+  } catch (error) {
+    if (error.code === "ENOENT") return {};
+    throw new Error(`failed to read remote config: ${error.message}`);
+  }
+}
+function writeRemoteConfig(config) {
+  const path = resolveConfigPath();
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(config, null, 2), "utf8");
+}
+function getDefaultRemote() {
+  const config = readRemoteConfig();
+  return config.defaultRemote;
+}
+function setDefaultRemote(rawUrl) {
+  const defaultRemote = normalizeRemoteUrl(rawUrl);
+  writeRemoteConfig({ ...readRemoteConfig(), defaultRemote });
+  return defaultRemote;
+}
+function clearDefaultRemote() {
+  const { defaultRemote: _drop, ...rest } = readRemoteConfig();
+  writeRemoteConfig(rest);
+}
+function getDefaultTarget() {
+  const configured = readRemoteConfig().defaultTarget;
+  return configured ?? DEFAULT_SESSION_TARGET;
+}
+function setDefaultTarget(value) {
+  writeRemoteConfig({ ...readRemoteConfig(), defaultTarget: value });
+}
+function getDefaultTools() {
+  return readRemoteConfig().defaultTools ?? [];
+}
+function setDefaultTools(tools) {
+  writeRemoteConfig({ ...readRemoteConfig(), defaultTools: tools });
+}
+function getPlugins() {
+  return readRemoteConfig().plugins ?? [];
+}
+function setPlugins(plugins) {
+  writeRemoteConfig({ ...readRemoteConfig(), plugins });
+}
+function getH2aConfig() {
+  const raw = readRemoteConfig().h2a ?? {};
+  return {
+    enabled: raw.enabled ?? false,
+    command: raw.command ?? DEFAULT_H2A_COMMAND
+  };
+}
+function getLlmMeshRuntimeConfig() {
+  const raw = readRemoteConfig().llmMesh ?? {};
+  return {
+    enabled: raw.enabled ?? false
+  };
+}
+function setLlmMeshRuntimeConfig(llmMesh) {
+  writeRemoteConfig({ ...readRemoteConfig(), llmMesh });
+}
+function getMaxConcurrent() {
+  const env = process.env.REMOTE_MAX_CONCURRENT;
+  if (env !== void 0) {
+    const n = Number.parseInt(env, 10);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  return readRemoteConfig().maxConcurrent;
+}
+var DEFAULT_JOB_MAX_AGE_HOURS = 24;
+function getJobMaxAgeHours() {
+  const env = process.env.REMOTE_JOB_MAX_AGE_HOURS;
+  if (env !== void 0) {
+    const n = Number.parseFloat(env);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  return DEFAULT_JOB_MAX_AGE_HOURS;
+}
+function getTunnel() {
+  return readRemoteConfig().tunnel;
+}
+function setTunnel(tunnel) {
+  writeRemoteConfig({ ...readRemoteConfig(), tunnel });
+}
+function getLayoutConfig() {
+  const raw = readRemoteConfig().layout ?? {};
+  return {
+    maxAgeHours: typeof raw.maxAgeHours === "number" ? raw.maxAgeHours : DEFAULT_LAYOUT.maxAgeHours,
+    maxPerWindow: typeof raw.maxPerWindow === "number" ? raw.maxPerWindow : DEFAULT_LAYOUT.maxPerWindow,
+    sharedWindows: typeof raw.sharedWindows === "number" ? raw.sharedWindows : DEFAULT_LAYOUT.sharedWindows,
+    multiSession: raw.multiSession && typeof raw.multiSession === "object" ? raw.multiSession : DEFAULT_LAYOUT.multiSession,
+    groups: Array.isArray(raw.groups) ? raw.groups : DEFAULT_LAYOUT.groups
+  };
+}
+function getToken() {
+  return process.env.REMOTE_TOKEN ?? readRemoteConfig().token;
+}
+function setToken(value) {
+  writeRemoteConfig({ ...readRemoteConfig(), token: value });
+}
+function authHeaders() {
+  const token = getToken();
+  return token ? { Authorization: `Bearer ${token}` } : {};
+}
+
+export {
+  DEFAULT_SESSION_TARGET,
+  resolveConfigPath,
+  getDefaultRemote,
+  setDefaultRemote,
+  clearDefaultRemote,
+  getDefaultTarget,
+  setDefaultTarget,
+  getDefaultTools,
+  setDefaultTools,
+  getPlugins,
+  setPlugins,
+  getH2aConfig,
+  getLlmMeshRuntimeConfig,
+  setLlmMeshRuntimeConfig,
+  getMaxConcurrent,
+  getJobMaxAgeHours,
+  getTunnel,
+  setTunnel,
+  getLayoutConfig,
+  setToken,
+  authHeaders
+};

package/dist/chunk-PG4CWJNC.js

@@ -0,0 +1,197 @@
+import {
+  authHeaders
+} from "./chunk-E3GXAKJ3.js";
+
+// src/workspace.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+var MARKER_DIR = ".remote";
+var MARKER_FILE = "workspace.json";
+var BASE_FILE = "base.tgz";
+var LINEAGES_DIR = ".remote/lineages";
+function baseSnapshotPath(cwd) {
+  return join(cwd, MARKER_DIR, BASE_FILE);
+}
+function readBaseSnapshot(cwd) {
+  const path = baseSnapshotPath(cwd);
+  if (!existsSync(path)) return null;
+  return readFileSync(path);
+}
+function writeBaseSnapshot(cwd, archive) {
+  const path = baseSnapshotPath(cwd);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, archive);
+}
+function markerPath(cwd) {
+  return join(cwd, MARKER_DIR, MARKER_FILE);
+}
+function readWorkspaceMarker(cwd) {
+  try {
+    const raw = readFileSync(markerPath(cwd), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.remote === "string" && typeof parsed.workspaceId === "string") {
+      return {
+        remote: parsed.remote,
+        workspaceId: parsed.workspaceId,
+        ...typeof parsed.path === "string" ? { path: parsed.path } : {},
+        ...typeof parsed.home === "string" ? { home: parsed.home } : {}
+      };
+    }
+    return void 0;
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw new Error(
+      `failed to read ${MARKER_DIR}/${MARKER_FILE}: ${error.message}`
+    );
+  }
+}
+function writeWorkspaceMarker(cwd, marker) {
+  const path = markerPath(cwd);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(marker, null, 2) + "\n", "utf8");
+}
+function lineageFilePath(cwd, workspaceId) {
+  const safe = workspaceId.replace(/[^a-zA-Z0-9-]/g, "_");
+  return join(cwd, LINEAGES_DIR, `${safe}.json`);
+}
+function readLineageRecord(cwd, workspaceId) {
+  try {
+    const raw = readFileSync(lineageFilePath(cwd, workspaceId), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.lineageId === "string") {
+      return {
+        lineageId: parsed.lineageId,
+        ...typeof parsed.remoteSessionId === "string" ? { remoteSessionId: parsed.remoteSessionId } : {}
+      };
+    }
+    return void 0;
+  } catch (err) {
+    if (err.code === "ENOENT") return void 0;
+    throw err;
+  }
+}
+function writeLineageRecord(cwd, workspaceId, record) {
+  const path = lineageFilePath(cwd, workspaceId);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(record, null, 2) + "\n", "utf8");
+}
+function joinUrl(base, path) {
+  return `${base.replace(/\/$/, "")}${path}`;
+}
+async function createWorkspace(baseUrl, body = {}, fetchImpl = fetch) {
+  const response = await fetchImpl(joinUrl(baseUrl, "/workspaces"), {
+    method: "POST",
+    headers: { "content-type": "application/json", ...authHeaders() },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    throw new Error(
+      `createWorkspace: ${response.status} ${response.statusText}`
+    );
+  }
+  const json = await response.json();
+  return json.workspace;
+}
+async function listWorkspaces(baseUrl, fetchImpl = fetch) {
+  const response = await fetchImpl(joinUrl(baseUrl, "/workspaces"), {
+    headers: { ...authHeaders() }
+  });
+  if (!response.ok) {
+    throw new Error(`listWorkspaces: ${response.status} ${response.statusText}`);
+  }
+  const json = await response.json();
+  return json.workspaces;
+}
+async function deleteWorkspace(baseUrl, workspaceId, fetchImpl = fetch) {
+  const response = await fetchImpl(
+    joinUrl(baseUrl, `/workspaces/${workspaceId}`),
+    { method: "DELETE", headers: { ...authHeaders() } }
+  );
+  if (response.status === 404) return false;
+  if (!response.ok) {
+    throw new Error(
+      `deleteWorkspace: ${response.status} ${response.statusText}`
+    );
+  }
+  return true;
+}
+async function downloadWorkspaceExport(baseUrl, sessionId, fetchImpl = fetch) {
+  const response = await fetchImpl(
+    joinUrl(baseUrl, `/sessions/${sessionId}/workspace/export`),
+    { headers: { ...authHeaders() } }
+  );
+  if (response.status === 404) return null;
+  if (!response.ok) {
+    throw new Error(
+      `downloadWorkspaceExport: ${response.status} ${response.statusText}`
+    );
+  }
+  return Buffer.from(await response.arrayBuffer());
+}
+async function acquireWorkspaceLock(baseUrl, workspaceId, holder, ttlSeconds = 300, fetchImpl = fetch) {
+  const response = await fetchImpl(
+    joinUrl(baseUrl, `/workspaces/${workspaceId}/lock`),
+    {
+      method: "POST",
+      headers: { "content-type": "application/json", ...authHeaders() },
+      body: JSON.stringify({ holder, ttlSeconds })
+    }
+  );
+  if (response.ok) return { acquired: true };
+  if (response.status === 409) {
+    const body = await response.json();
+    return {
+      acquired: false,
+      holder: body.holder ?? "unknown",
+      since: body.acquiredAt ?? "unknown"
+    };
+  }
+  throw new Error(
+    `acquireWorkspaceLock: ${response.status} ${response.statusText}`
+  );
+}
+async function releaseWorkspaceLock(baseUrl, workspaceId, fetchImpl = fetch) {
+  await fetchImpl(joinUrl(baseUrl, `/workspaces/${workspaceId}/lock`), {
+    method: "DELETE",
+    headers: { ...authHeaders() }
+  }).catch(() => {
+  });
+}
+function lockHolderId() {
+  const user = process.env.USER ?? process.env.USERNAME ?? "user";
+  const host = process.env.HOSTNAME ?? process.env.HOST ?? "local";
+  return `${user}@${host}`;
+}
+async function requestWorkspaceGc(baseUrl, body, fetchImpl = fetch) {
+  const response = await fetchImpl(joinUrl(baseUrl, "/workspaces/gc"), {
+    method: "POST",
+    headers: { "content-type": "application/json", ...authHeaders() },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const detail = await response.json().then((json) => json.message ?? "").catch(() => "");
+    throw new Error(
+      `workspace gc: ${response.status} ${response.statusText}${detail ? ` \u2014 ${detail}` : ""}`
+    );
+  }
+  return await response.json();
+}
+
+export {
+  baseSnapshotPath,
+  readBaseSnapshot,
+  writeBaseSnapshot,
+  markerPath,
+  readWorkspaceMarker,
+  writeWorkspaceMarker,
+  readLineageRecord,
+  writeLineageRecord,
+  createWorkspace,
+  listWorkspaces,
+  deleteWorkspace,
+  downloadWorkspaceExport,
+  acquireWorkspaceLock,
+  releaseWorkspaceLock,
+  lockHolderId,
+  requestWorkspaceGc
+};

package/dist/chunk-RLFQALHC.js

@@ -0,0 +1,45 @@
+// src/sync-status.ts
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function syncStatusPath(sessionId) {
+  return join(homedir(), ".remote", "sync-status", `${sessionId}.json`);
+}
+function readSyncStatus(sessionId) {
+  const p = syncStatusPath(sessionId);
+  try {
+    return JSON.parse(readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeSyncStatus(sessionId, status) {
+  const p = syncStatusPath(sessionId);
+  mkdirSync(join(homedir(), ".remote", "sync-status"), { recursive: true });
+  const tmp = `${p}.tmp`;
+  writeFileSync(tmp, JSON.stringify(status, null, 2), "utf8");
+  renameSync(tmp, p);
+}
+function emptyMetrics() {
+  return {
+    pendingBytes: 0,
+    pendingCount: 0,
+    oldestPendingAge: 0,
+    lastAckedAt: null,
+    estimatedCatchup: 0
+  };
+}
+function mergedState(classes) {
+  if (classes.includes("blocked")) return "blocked";
+  if (classes.includes("degraded")) return "degraded";
+  if (classes.includes("pending")) return "pending";
+  return "synced";
+}
+
+export {
+  syncStatusPath,
+  readSyncStatus,
+  writeSyncStatus,
+  emptyMetrics,
+  mergedState
+};