@runwingman/flightdeck-cli 0.2.0

package/src/client.js

@@ -0,0 +1,285 @@
+import { createNip98AuthHeader } from './nostr.js';
+import {
+  RecordManager,
+  buildLegacyWriteGroupFields,
+} from '@nostr-superbased/core/records';
+
+function getCheckoutPolicyConfig(config = {}, options = {}) {
+  return options.checkoutPolicy
+    || config.recordCheckoutPolicy
+    || config.record_checkout_policy
+    || config.checkoutPolicy
+    || null;
+}
+
+export class SuperbasedClient {
+  constructor({ config, session, groupKeys }) {
+    this.config = config;
+    this.session = session;
+    this.groupKeys = groupKeys;
+    this._authSecret = null;
+  }
+
+  setAuthSecret(secret) {
+    this._authSecret = secret;
+  }
+
+  get authSecret() {
+    return this._authSecret ?? this.session.secret;
+  }
+
+  url(pathname) {
+    return new URL(pathname, this.config.directHttpsUrl).toString();
+  }
+
+  async requestRaw(pathname, { method = 'GET', body = null, authHeader = null, headers = {} } = {}) {
+    const url = this.url(pathname);
+    const authorization = authHeader || createNip98AuthHeader(url, method, body, this.authSecret);
+    return fetch(url, {
+      method,
+      headers: {
+        Authorization: authorization,
+        ...(body != null ? { 'Content-Type': 'application/json' } : {}),
+        ...headers,
+      },
+      body: body != null ? JSON.stringify(body) : undefined,
+    });
+  }
+
+  async request(pathname, options = {}) {
+    const response = await this.requestRaw(pathname, options);
+    if (!response.ok) {
+      const text = await response.text().catch(() => '');
+      let payload = null;
+      try {
+        payload = text ? JSON.parse(text) : null;
+      } catch {
+        payload = null;
+      }
+      const code = typeof payload?.code === 'string' ? payload.code : null;
+      if (code === 'checkout_required' || code === 'checkout_missing') {
+        throw new Error(`API ${response.status} (${code}): this record requires checkout before editing. Sync first, acquire checkout in the app, then retry the write.`);
+      }
+      if (code === 'edit_policy_forbidden') {
+        throw new Error(`API ${response.status} (${code}): this record is not editable by the current user or group.`);
+      }
+      throw new Error(`API ${response.status}${code ? ` (${code})` : ''}: ${text}`);
+    }
+    return response.json();
+  }
+
+  registerWorkspaceKey(body) {
+    return this.request('/api/v4/user/workspace-keys', {
+      method: 'POST',
+      body,
+    });
+  }
+
+  listWorkspaceKeys() {
+    return this.request('/api/v4/user/workspace-keys');
+  }
+
+  fetchWorkspaceKeyMappings(workspaceOwnerNpub) {
+    return this.request(`/api/v4/user/workspace-key-mappings?workspace_owner_npub=${encodeURIComponent(workspaceOwnerNpub)}`);
+  }
+
+  fetchWorkspaceAppSchemas({ appNpub = null, latest = true } = {}) {
+    const params = new URLSearchParams();
+    if (appNpub) params.set('app_npub', appNpub);
+    if (latest !== undefined) params.set('latest', latest ? 'true' : 'false');
+    const qs = params.toString();
+    return this.request(`/api/v4/workspaces/${encodeURIComponent(this.config.workspaceOwnerNpub)}/app-schemas${qs ? `?${qs}` : ''}`);
+  }
+
+  getGroups() {
+    return this.request(`/api/v4/groups?npub=${encodeURIComponent(this.session.npub)}`);
+  }
+
+  getGroupKeys() {
+    return this.request(`/api/v4/groups/keys?member_npub=${encodeURIComponent(this.session.npub)}`);
+  }
+
+  rotateGroup(groupId, body) {
+    return this.request(`/api/v4/groups/${encodeURIComponent(groupId)}/rotate`, {
+      method: 'POST',
+      body,
+    });
+  }
+
+  async fetchRecords(recordFamilyHash, since = null) {
+    const PAGE_SIZE = 200;
+    let offset = 0;
+    let allRecords = [];
+
+    while (true) {
+      const params = new URLSearchParams({
+        owner_npub: this.config.workspaceOwnerNpub,
+        viewer_npub: this.session.npub,
+        record_family_hash: recordFamilyHash,
+        limit: String(PAGE_SIZE),
+        offset: String(offset),
+      });
+      if (since) params.set('since', since);
+      const page = await this.request(`/api/v4/records?${params.toString()}`);
+      const records = page.records ?? [];
+      allRecords = allRecords.concat(records);
+      if (!page.has_more || records.length === 0) break;
+      offset += records.length;
+    }
+
+    return { records: allRecords };
+  }
+
+  getRecordHistory(recordId) {
+    const params = new URLSearchParams({
+      owner_npub: this.config.workspaceOwnerNpub,
+      viewer_npub: this.session.npub,
+    });
+    return this.request(`/api/v4/records/${encodeURIComponent(recordId)}/history?${params.toString()}`);
+  }
+
+  async syncRecords(records, options = {}) {
+    const normalizedRecords = (records || []).map((record) => {
+      const normalized = {
+        ...record,
+        owner_npub: record.owner_npub || this.config.workspaceOwnerNpub,
+        workspace_service_npub: record.workspace_service_npub || record.owner_npub || this.config.workspaceOwnerNpub,
+        user_npub: record.user_npub || this.session.userNpub || this.session.npub,
+      };
+      const workspaceUserKeyNpub = String(record.workspace_user_key_npub || '').trim()
+        || (record.signature_npub && record.signature_npub !== this.session.npub ? record.signature_npub : '');
+      if (workspaceUserKeyNpub) {
+        normalized.workspace_user_key_npub = workspaceUserKeyNpub;
+      }
+
+      delete normalized.write_group_id;
+      delete normalized.write_group_npub;
+      Object.assign(normalized, buildLegacyWriteGroupFields({
+        writeGroupId: record?.write_group_id,
+        writeGroupRef: record?.write_group_npub,
+      }));
+      return normalized;
+    });
+    if (normalizedRecords.length === 0) {
+      const workspaceServiceNpub = this.config.workspaceServiceNpub || this.config.workspaceOwnerNpub;
+      const userNpub = this.session.userNpub || this.session.npub;
+      return this.request('/api/v4/records/sync', {
+        method: 'POST',
+        body: {
+          owner_npub: workspaceServiceNpub,
+          workspace_service_npub: workspaceServiceNpub,
+          user_npub: userNpub,
+          actor_npub: userNpub,
+          viewer_npub: userNpub,
+          records: [],
+          group_write_tokens: {},
+        },
+      });
+    }
+    const workspaceUserKeyNpubs = [...new Set(normalizedRecords
+      .map((record) => String(record.workspace_user_key_npub || '').trim())
+      .filter(Boolean))];
+    const workspaceUserKeyNpub = workspaceUserKeyNpubs.length === 1 ? workspaceUserKeyNpubs[0] : null;
+    const identityContext = {
+      workspaceServiceNpub: this.config.workspaceServiceNpub || this.config.workspaceOwnerNpub,
+      userNpub: this.session.userNpub || this.session.npub,
+      ...(workspaceUserKeyNpub ? {
+        workspaceUserKeyNpub,
+        signerNpub: workspaceUserKeyNpub,
+      } : {}),
+    };
+    const recordManager = new RecordManager({
+      buildUrl: (pathname) => this.url(pathname),
+      getIdentityContext: () => identityContext,
+      getGroupKey: (groupRef) => (
+        this.groupKeys.getCurrent
+          ? this.groupKeys.getCurrent(groupRef)
+          : this.groupKeys.get(groupRef)
+      ),
+    });
+    const syncRequest = await recordManager.buildCheckoutAwareSyncRequest({
+      records: normalizedRecords,
+      identityContext,
+      checkout: options.checkout,
+      checkoutsByRecordId: options.checkoutsByRecordId,
+      checkoutPolicy: getCheckoutPolicyConfig(this.config, options) || undefined,
+    });
+    return this.request('/api/v4/records/sync', {
+      method: 'POST',
+      body: {
+        owner_npub: syncRequest.owner_npub,
+        workspace_service_npub: syncRequest.workspace_service_npub,
+        ...(syncRequest.user_npub ? { user_npub: syncRequest.user_npub } : {}),
+        ...(syncRequest.actor_npub ? { actor_npub: syncRequest.actor_npub } : {}),
+        ...(syncRequest.viewer_npub ? { viewer_npub: syncRequest.viewer_npub } : {}),
+        ...(syncRequest.signer_npub ? { signer_npub: syncRequest.signer_npub } : {}),
+        ...(syncRequest.workspace_user_key_npub ? { workspace_user_key_npub: syncRequest.workspace_user_key_npub } : {}),
+        ...(syncRequest.ws_key_npub ? { ws_key_npub: syncRequest.ws_key_npub } : {}),
+        records: syncRequest.records,
+        group_write_tokens: syncRequest.group_write_tokens,
+      },
+    });
+  }
+
+  getStorageDownloadUrl(objectId) {
+    return this.request(`/api/v4/storage/${objectId}/download-url`);
+  }
+
+  getStorageObject(objectId) {
+    return this.request(`/api/v4/storage/${objectId}`);
+  }
+
+  getStorageContentUrl(objectId) {
+    return this.url(`/api/v4/storage/${objectId}/content`);
+  }
+
+  async getStorageContent(objectId) {
+    const response = await this.requestRaw(`/api/v4/storage/${objectId}/content`);
+    if (!response.ok) {
+      const text = await response.text().catch(() => '');
+      throw new Error(`API ${response.status}: ${text}`);
+    }
+    return new Uint8Array(await response.arrayBuffer());
+  }
+
+  prepareStorageObject(body) {
+    return this.request('/api/v4/storage/prepare', {
+      method: 'POST',
+      body,
+    });
+  }
+
+  async uploadPreparedStorageObject(prepared, bytes, contentType = 'application/octet-stream') {
+    const uploadUrl = String(prepared?.upload_url || '').trim();
+    if (!uploadUrl) {
+      throw new Error('Missing upload URL for storage object.');
+    }
+    const directResponse = await fetch(uploadUrl, {
+      method: 'PUT',
+      headers: {
+        'Content-Type': contentType,
+      },
+      body: bytes,
+    });
+    if (directResponse.ok) {
+      return {
+        object_id: prepared.object_id,
+        size_bytes: bytes.byteLength,
+        content_type: contentType,
+      };
+    }
+    return this.request(`/api/v4/storage/${prepared.object_id}`, {
+      method: 'PUT',
+      body: {
+        base64_data: Buffer.from(bytes).toString('base64'),
+      },
+    });
+  }
+
+  completeStorageObject(objectId, body = {}) {
+    return this.request(`/api/v4/storage/${objectId}/complete`, {
+      method: 'POST',
+      body,
+    });
+  }
+}

package/src/config.js

@@ -0,0 +1,117 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseConnectionToken } from './token.js';
+import { loadBetterSqlite3 } from './sqlite-runtime.js';
+
+function getDefaultStateDir() {
+  return path.resolve(process.cwd(), '.flightdeck-cli');
+}
+
+function getYokeStateDir() {
+  return path.resolve(process.cwd(), '.wingman-yoke');
+}
+
+function getLegacyStateDir() {
+  return path.resolve(process.cwd(), '.wingman-ap');
+}
+
+function resolveStateDir(dir) {
+  return path.resolve(String(dir || '').trim());
+}
+
+export function getStateDir() {
+  const override = String(process.env.FLIGHTDECK_CLI_STATE_DIR || '').trim();
+  if (override) return resolveStateDir(override);
+  const yokeOverride = String(process.env.WINGMAN_YOKE_STATE_DIR || '').trim();
+  if (yokeOverride) return resolveStateDir(yokeOverride);
+  const legacyOverride = String(process.env.WINGMAN_AP_STATE_DIR || '').trim();
+  if (legacyOverride) return resolveStateDir(legacyOverride);
+  const defaultDir = getDefaultStateDir();
+  if (fs.existsSync(defaultDir)) return defaultDir;
+  const yokeDir = getYokeStateDir();
+  if (fs.existsSync(yokeDir)) return yokeDir;
+  const legacyDir = getLegacyStateDir();
+  if (fs.existsSync(legacyDir)) return legacyDir;
+  return defaultDir;
+}
+
+export function getConfigPath() {
+  return path.join(getStateDir(), 'config.json');
+}
+
+export function getDbPath() {
+  const stateDir = getStateDir();
+  const preferredPath = path.join(stateDir, 'flightdeck-cli.db');
+  if (fs.existsSync(preferredPath)) return preferredPath;
+  const yokePath = path.join(stateDir, 'yoke.db');
+  if (fs.existsSync(yokePath)) return yokePath;
+  const legacyPath = path.join(stateDir, 'autopilot.db');
+  if (fs.existsSync(legacyPath)) return legacyPath;
+  return preferredPath;
+}
+
+export function ensureStateDir() {
+  fs.mkdirSync(getStateDir(), { recursive: true });
+}
+
+function withConfigDb(fn) {
+  ensureStateDir();
+  const Database = loadBetterSqlite3();
+  const db = new Database(getDbPath());
+  db.exec(`CREATE TABLE IF NOT EXISTS app_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)`);
+  try {
+    return fn(db);
+  } finally {
+    db.close();
+  }
+}
+
+function loadConfigFromDb() {
+  return withConfigDb((db) => {
+    const row = db.prepare(`SELECT value FROM app_meta WHERE key = 'config:current'`).get();
+    return row?.value ? JSON.parse(row.value) : null;
+  });
+}
+
+function saveConfigToDb(nextConfig) {
+  withConfigDb((db) => {
+    db.prepare(`
+      INSERT INTO app_meta (key, value)
+      VALUES ('config:current', ?)
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value
+    `).run(JSON.stringify(nextConfig));
+  });
+}
+
+export function loadConfig() {
+  ensureStateDir();
+  const dbConfig = loadConfigFromDb();
+  if (dbConfig) return dbConfig;
+  const configPath = getConfigPath();
+  if (!fs.existsSync(configPath)) return null;
+  return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+}
+
+export function saveConfig(nextConfig) {
+  ensureStateDir();
+  saveConfigToDb(nextConfig);
+  fs.writeFileSync(getConfigPath(), `${JSON.stringify(nextConfig, null, 2)}\n`, 'utf8');
+}
+
+export function initConfigFromToken(rawToken) {
+  const parsed = parseConnectionToken(rawToken);
+  const config = {
+    version: 1,
+    token: parsed.rawToken,
+    directHttpsUrl: parsed.directHttpsUrl,
+    serviceNpub: parsed.serviceNpub,
+    workspaceOwnerNpub: parsed.workspaceOwnerNpub,
+    workspaceOwnerPubkey: parsed.workspaceOwnerPubkey,
+    appNpub: parsed.appNpub,
+    appPubkey: parsed.appPubkey,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  };
+  saveConfig(config);
+  return config;
+}