@callcorpacd/sandbox-cli 0.1.0

package/README.md

@@ -0,0 +1,19 @@
+# @callcorpacd/sandbox-cli
+
+CLI for CallCorp sandboxed guest apps.
+
+```bash
+callcorp-sandbox login
+callcorp-sandbox whoami
+callcorp-sandbox embed-snippet --mode dev|prod
+callcorp-sandbox publish [--target platform-file|mass-storage] [--no-build] [--owner-id <id>]
+```
+
+Credentials are resolved in order:
+
+1. `~/.callcorp/sandbox.json` (API base + API key and/or access token)
+2. A parent BuildCC workspace: `.buildcc/secrets.json` (`apiKey`) and optional `.buildcc/workspace.json` (`host`)
+
+If either source has a key, `publish` / `whoami` work without running `login`. Interactive `login` defaults to a discovered BuildCC key when present.
+
+See [`../PlatformBridge/AUTHORING.md`](../PlatformBridge/AUTHORING.md). Template catalog: [`../create-callcorp-sandbox/templates/README.md`](../create-callcorp-sandbox/templates/README.md). Partners: [`../create-callcorp-sandbox/PARTNER.md`](../create-callcorp-sandbox/PARTNER.md). Scaffolded apps include a stack-specific `AGENTS.md` for assistant-oriented guidance.

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@callcorpacd/sandbox-cli",
+  "version": "0.1.0",
+  "description": "Login, publish, and embed-snippet helpers for CallCorp sandboxed guest apps",
+  "type": "module",
+  "bin": {
+    "callcorp-sandbox": "./src/cli.js"
+  },
+  "main": "./src/cli.js",
+  "files": [
+    "src"
+  ],
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/cli.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loginCommand } from './login.js';
+import { whoamiCommand } from './whoami.js';
+import { publishCommand } from './publish.js';
+import { embedSnippetCommand } from './embedSnippet.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function printHelp() {
+  console.log(`callcorp-sandbox — CallCorp sandboxed guest tooling
+
+Commands:
+  login                         Store API base URL + API key (or access token)
+  whoami                        Validate credentials (Apps/User/FullName)
+  publish [--target ...]        Build (unless --no-build) and upload dist/
+  embed-snippet --mode dev|prod Print SandboxedApp JSON for the current project
+
+Global options:
+  --cwd <path>                  Project directory (default: cwd)
+  -h, --help                    Show help
+`);
+}
+
+function parseGlobal(argv) {
+  const out = { cmd: null, args: [], cwd: process.cwd() };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '-h' || a === '--help') out.help = true;
+    else if (a === '--cwd') out.cwd = path.resolve(argv[++i]);
+    else if (!out.cmd && !a.startsWith('-')) out.cmd = a;
+    else out.args.push(a);
+  }
+  return out;
+}
+
+async function main() {
+  const opts = parseGlobal(process.argv);
+  if (opts.help || !opts.cmd) {
+    printHelp();
+    process.exit(opts.help ? 0 : 1);
+  }
+
+  process.chdir(opts.cwd);
+
+  switch (opts.cmd) {
+    case 'login':
+      await loginCommand(opts.args);
+      break;
+    case 'whoami':
+      await whoamiCommand(opts.args);
+      break;
+    case 'publish':
+      await publishCommand(opts.args);
+      break;
+    case 'embed-snippet':
+      await embedSnippetCommand(opts.args);
+      break;
+    default:
+      console.error(`Unknown command: ${opts.cmd}`);
+      printHelp();
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error(err?.message || err);
+  process.exit(1);
+});

package/src/config.js

@@ -0,0 +1,149 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export function configPath() {
+  return path.join(os.homedir(), '.callcorp', 'sandbox.json');
+}
+
+export function loadConfig() {
+  const p = configPath();
+  if (!fs.existsSync(p))
+    return null;
+  return JSON.parse(fs.readFileSync(p, 'utf8'));
+}
+
+export function saveConfig(config) {
+  const p = configPath();
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
+  return p;
+}
+
+export function loadManifest(cwd = process.cwd()) {
+  const p = path.join(cwd, 'callcorp.sandbox.json');
+  if (!fs.existsSync(p))
+    throw new Error(`callcorp.sandbox.json not found in ${cwd}`);
+  return { path: p, data: JSON.parse(fs.readFileSync(p, 'utf8')) };
+}
+
+function normalizeApiBase(hostOrUrl) {
+  const raw = String(hostOrUrl || 'api.callcorp.com').trim().replace(/\/+$/, '');
+  if (/^https?:\/\//i.test(raw))
+    return raw;
+  return `https://${raw}`;
+}
+
+/**
+ * Walk ancestors for a BuildCC workspace (`.buildcc/secrets.json` with apiKey).
+ * Same idea as BuildCC WorkspaceConfig.ResolveWorkspaceRoot.
+ * @returns {{ apiBase: string, apiKey: string, source: string } | null}
+ */
+export function findBuildCcAuth(startDir = process.cwd()) {
+  let dir = path.resolve(startDir);
+  for (;;) {
+    const buildCcDir = path.join(dir, '.buildcc');
+    const secretsPath = path.join(buildCcDir, 'secrets.json');
+    if (fs.existsSync(secretsPath)) {
+      try {
+        const secrets = JSON.parse(fs.readFileSync(secretsPath, 'utf8'));
+        const apiKey = secrets?.apiKey || secrets?.ApiKey;
+        if (apiKey && String(apiKey).trim()) {
+          let host = 'api.callcorp.com';
+          const workspacePath = path.join(buildCcDir, 'workspace.json');
+          if (fs.existsSync(workspacePath)) {
+            const binding = JSON.parse(fs.readFileSync(workspacePath, 'utf8'));
+            host = binding?.host || binding?.Host || host;
+          }
+          return {
+            apiBase: normalizeApiBase(host),
+            apiKey: String(apiKey).trim(),
+            source: secretsPath,
+          };
+        }
+      } catch {
+        // keep walking
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+
+export function requireAuth() {
+  const cfg = loadConfig();
+  if (cfg?.apiBase && (cfg.apiKey || cfg.accessToken))
+    return cfg;
+
+  const buildCc = findBuildCcAuth();
+  if (buildCc) {
+    return {
+      apiBase: buildCc.apiBase,
+      apiKey: buildCc.apiKey,
+      accessToken: undefined,
+      updatedAt: undefined,
+      fromBuildCc: buildCc.source,
+    };
+  }
+
+  if (!cfg?.apiBase)
+    throw new Error('Not logged in. Run: callcorp-sandbox login (or bind a BuildCC workspace with .buildcc/secrets.json)');
+  throw new Error('No apiKey or accessToken in config. Run: callcorp-sandbox login');
+}
+
+export function apiUrl(apiBase, pathAndQuery) {
+  const base = String(apiBase).replace(/\/+$/, '');
+  const path = String(pathAndQuery).replace(/^\/+/, '');
+  return `${base}/${path}`;
+}
+
+/**
+ * Authenticated fetch. Prefers access_token header; also sends apikey query when present
+ * (BuildCC-style non-interactive auth).
+ */
+export async function apiFetch(cfg, method, pathAndQuery, { body, headers, isBinary } = {}) {
+  let url = apiUrl(cfg.apiBase, pathAndQuery);
+  if (cfg.apiKey) {
+    const u = new URL(url);
+    u.searchParams.set('apikey', cfg.apiKey);
+    url = u.toString();
+  }
+
+  const reqHeaders = { ...(headers || {}) };
+  if (cfg.accessToken)
+    reqHeaders.access_token = cfg.accessToken;
+
+  const init = { method: method || 'GET', headers: reqHeaders };
+  if (body !== undefined) {
+    init.body = body;
+    const isForm = typeof FormData !== 'undefined' && body instanceof FormData;
+    if (!isBinary && !isForm && !reqHeaders['Content-Type'] && typeof body === 'string')
+      reqHeaders['Content-Type'] = 'application/json';
+    if (isForm)
+      delete reqHeaders['Content-Type'];
+  }
+
+  const res = await fetch(url, init);
+  const text = await res.text();
+  let data = text;
+  try {
+    data = text ? JSON.parse(text) : null;
+  } catch {
+    // keep text
+  }
+
+  if (!res.ok) {
+    const msg = typeof data === 'object' && data
+      ? (data.Message || data.message || JSON.stringify(data))
+      : text;
+    const err = new Error(`API ${method} ${pathAndQuery} failed (${res.status}): ${String(msg).slice(0, 400)}`);
+    err.status = res.status;
+    err.data = data;
+    throw err;
+  }
+
+  return data;
+}

package/src/embedSnippet.js

@@ -0,0 +1,56 @@
+import { loadManifest } from './config.js';
+
+function parseArgs(args) {
+  const out = { mode: 'dev' };
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--mode') out.mode = args[++i];
+  }
+  return out;
+}
+
+export async function embedSnippetCommand(args) {
+  const { mode } = parseArgs(args);
+  const { data: manifest } = loadManifest();
+  const prefixes = manifest.allowedApiPrefixes || ['Apps/User/'];
+  const appId = manifest.appId || 'app';
+  const port = manifest.localDevPort || 5174;
+  const contentPath = (manifest.contentPath || `PartnerContent/${appId}`).replace(/\/+$/, '');
+  const target = manifest.target || 'platform-file';
+
+  let snippet;
+  // Params: flat string map; values may use portal interpolations ({{ }} / {# #}).
+  // Guest reads them via platform.context.params after handshake.
+  const exampleParams = {
+    Mode: mode === 'dev' ? 'dev' : 'prod',
+  };
+
+  if (mode === 'dev') {
+    snippet = {
+      ControlType: 'SandboxedApp',
+      ControlData: {
+        Name: `${appId}Dev`,
+        SourceKind: 'Url',
+        Url: manifest.localDevUrl || `https://localhost:${port}/`,
+        AllowedApiPrefixes: prefixes,
+        Params: exampleParams,
+      },
+    };
+  }
+  else if (mode === 'prod') {
+    const controlData = {
+      Name: appId,
+      SourceKind: target === 'mass-storage' ? 'MassStorage' : 'PlatformFile',
+      ContentPath: `${contentPath}/index.html`,
+      AllowedApiPrefixes: prefixes,
+      Params: exampleParams,
+    };
+    if (target === 'mass-storage')
+      controlData.OwnerId = '{# Root.CustomerID #}';
+    snippet = { ControlType: 'SandboxedApp', ControlData: controlData };
+  }
+  else {
+    throw new Error(`Unknown mode: ${mode} (use dev|prod)`);
+  }
+
+  console.log(JSON.stringify(snippet, null, 2));
+}

package/src/login.js

@@ -0,0 +1,74 @@
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { loadConfig, saveConfig, findBuildCcAuth } from './config.js';
+
+function parseArgs(args) {
+  const out = {};
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--api-base') out.apiBase = args[++i];
+    else if (a === '--api-key') out.apiKey = args[++i];
+    else if (a === '--access-token') out.accessToken = args[++i];
+  }
+  return out;
+}
+
+async function prompt(rl, question, fallback = '', displayFallback) {
+  const shown = displayFallback !== undefined ? displayFallback : fallback;
+  const suffix = shown ? ` (${shown})` : '';
+  const answer = (await rl.question(`${question}${suffix}: `)).trim();
+  return answer || fallback;
+}
+
+function maskKey(key) {
+  const s = String(key || '');
+  if (s.length <= 8)
+    return '********';
+  return `${s.slice(0, 4)}…${s.slice(-4)}`;
+}
+
+export async function loginCommand(args) {
+  const flags = parseArgs(args);
+  const existing = loadConfig() || {};
+  const buildCc = findBuildCcAuth();
+  const rl = readline.createInterface({ input, output });
+
+  try {
+    const defaultBase = flags.apiBase
+      || existing.apiBase
+      || buildCc?.apiBase
+      || 'https://api.callcorp.com';
+    const defaultKey = flags.apiKey || existing.apiKey || buildCc?.apiKey || '';
+
+    if (buildCc && !flags.apiKey && !existing.apiKey)
+      console.log(`Found BuildCC API key at ${buildCc.source} (${maskKey(buildCc.apiKey)})`);
+
+    const apiBase = flags.apiBase
+      || await prompt(rl, 'API base URL', defaultBase);
+    const apiKey = flags.apiKey
+      || await prompt(
+        rl,
+        'API key (preferred for CLI; leave blank to use access token)',
+        defaultKey,
+        defaultKey ? maskKey(defaultKey) : '',
+      );
+    let accessToken = flags.accessToken || existing.accessToken || '';
+    if (!apiKey && !flags.accessToken)
+      accessToken = await prompt(rl, 'Access token', accessToken);
+
+    if (!apiKey && !accessToken)
+      throw new Error('Provide an API key or an access token');
+
+    const cfg = {
+      apiBase: apiBase.replace(/\/+$/, ''),
+      apiKey: apiKey || undefined,
+      accessToken: accessToken || undefined,
+      updatedAt: new Date().toISOString(),
+    };
+    const p = saveConfig(cfg);
+    console.log(`Saved credentials to ${p}`);
+  }
+  finally {
+    rl.close();
+  }
+}

package/src/publish.js

@@ -0,0 +1,151 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { requireAuth, loadManifest, apiFetch } from './config.js';
+
+function parseArgs(args) {
+  const out = { noBuild: false, target: null, dist: 'dist' };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--no-build') out.noBuild = true;
+    else if (a === '--target') out.target = args[++i];
+    else if (a === '--dist') out.dist = args[++i];
+    else if (a === '--owner-id') out.ownerId = args[++i];
+  }
+  return out;
+}
+
+function walkFiles(dir) {
+  const results = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory())
+      results.push(...walkFiles(full));
+    else
+      results.push(full);
+  }
+  return results;
+}
+
+function metaDataTypeForFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  if (ext === '.html' || ext === '.htm') return 'Html';
+  if (ext === '.js' || ext === '.mjs') return 'Javascript';
+  if (ext === '.css') return 'Css';
+  if (ext === '.json') return 'Json';
+  if (ext === '.png') return 'Png';
+  if (ext === '.jpg' || ext === '.jpeg') return 'Jpeg';
+  if (ext === '.svg') return 'Svg';
+  if (ext === '.woff2') return 'Woff2';
+  if (ext === '.woff') return 'Woff';
+  if (ext === '.map') return 'Json';
+  return 'Binary';
+}
+
+function contentTypeForFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const map = {
+    '.html': 'text/html',
+    '.htm': 'text/html',
+    '.js': 'text/javascript',
+    '.mjs': 'text/javascript',
+    '.css': 'text/css',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.svg': 'image/svg+xml',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.map': 'application/json',
+  };
+  return map[ext] || 'application/octet-stream';
+}
+
+async function uploadPlatformFile(cfg, remotePath, localFile) {
+  const bytes = fs.readFileSync(localFile);
+  // Apps/FileBinary2?FullNameWithPath=... multipart (same as BasicFileUpload default)
+  const form = new FormData();
+  const blob = new Blob([bytes], { type: contentTypeForFile(localFile) });
+  form.append('uploadedFile', blob, path.basename(localFile));
+
+  const q = encodeURIComponent(remotePath);
+  await apiFetch(cfg, 'POST', `Apps/FileBinary2?FullNameWithPath=${q}`, {
+    body: form,
+    isBinary: true,
+  });
+}
+
+async function uploadMassStorage(cfg, ownerId, remotePath, localFile) {
+  const bytes = fs.readFileSync(localFile);
+  const meta = metaDataTypeForFile(localFile);
+  const pathPart = `${encodeURIComponent(ownerId)}/${remotePath.split('/').map(encodeURIComponent).join('/')}`;
+  await apiFetch(
+    cfg,
+    'PUT',
+    `Apps/FileMassStorage/${pathPart}?metaDataType=${encodeURIComponent(meta)}&isBinary=true`,
+    {
+      body: bytes,
+      headers: { 'Content-Type': contentTypeForFile(localFile) },
+      isBinary: true,
+    }
+  );
+}
+
+export async function publishCommand(args) {
+  const flags = parseArgs(args);
+  const cfg = requireAuth();
+  const { data: manifest } = loadManifest();
+  const target = flags.target || manifest.target || 'platform-file';
+  const contentRoot = (manifest.contentPath || `PartnerContent/${manifest.appId || 'app'}`).replace(/^\/+|\/+$/g, '');
+  const distDir = path.resolve(process.cwd(), flags.dist);
+
+  if (!flags.noBuild) {
+    console.log('Running npm run build…');
+    // Windows: spawnSync('npm.cmd', args, { shell: false }) fails with EINVAL.
+    // Pass a single command string with shell: true (avoids DEP0190 arg concatenation).
+    const build = spawnSync('npm run build', {
+      stdio: 'inherit',
+      shell: true,
+      cwd: process.cwd(),
+      env: process.env,
+    });
+    if (build.error)
+      throw new Error(`Build failed to start: ${build.error.message}`);
+    if (build.status !== 0)
+      throw new Error(`Build failed (exit ${build.status ?? 'unknown'})`);
+  }
+
+  if (!fs.existsSync(distDir))
+    throw new Error(`dist not found: ${distDir} (run npm run build or omit --no-build)`);
+
+  const files = walkFiles(distDir);
+  if (files.length === 0)
+    throw new Error(`No files in ${distDir}`);
+
+  let ownerId = flags.ownerId || cfg.ownerId || manifest.ownerId;
+  if (target === 'mass-storage' && !ownerId) {
+    // Best-effort: whoami-style call may not return CustomerID; require explicit owner.
+    throw new Error('Mass Storage publish requires --owner-id (customer/owner id)');
+  }
+
+  console.log(`Publishing ${files.length} file(s) to ${target} under ${contentRoot}/`);
+
+  for (const localFile of files) {
+    const rel = path.relative(distDir, localFile).split(path.sep).join('/');
+    const remotePath = `${contentRoot}/${rel}`;
+    process.stdout.write(`  ${remotePath} … `);
+    if (target === 'mass-storage')
+      await uploadMassStorage(cfg, ownerId, remotePath, localFile);
+    else
+      await uploadPlatformFile(cfg, remotePath, localFile);
+    console.log('ok');
+  }
+
+  console.log('\nPublish complete.');
+  console.log('Prod SandboxedApp ContentPath:', `${contentRoot}/index.html`);
+  if (target === 'platform-file')
+    console.log('SourceKind: PlatformFile');
+  else
+    console.log(`SourceKind: MassStorage, OwnerId: ${ownerId}`);
+}

package/src/whoami.js

@@ -0,0 +1,7 @@
+import { requireAuth, apiFetch } from './config.js';
+
+export async function whoamiCommand() {
+  const cfg = requireAuth();
+  const result = await apiFetch(cfg, 'GET', 'Apps/User/FullName');
+  console.log(JSON.stringify(result, null, 2));
+}