incremnt 0.1.0

package/src/lib.js

@@ -0,0 +1,341 @@
+import fs from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import { capabilities, contractVersion, officialCommands, readCommands } from './contract.js';
+import {
+  bootstrapSessionFromRemoteBaseUrl,
+  bootstrapSessionFromRemoteBaseUrlWithDeviceFlow,
+  bootstrapSessionFromRemoteBaseUrlWithEmail,
+  bootstrapSessionFromSnapshot,
+  fetchRemoteAuthConfig,
+  importSessionFile
+} from './auth.js';
+import { clearSessionState, isSessionExpired, readSessionState, resolveConfigDir } from './state.js';
+import { createTransport } from './transport.js';
+import { formatPretty } from './format.js';
+
+function parseArgs(argv) {
+  const commandTokens = [];
+  const rest = [];
+  let parsingOptions = false;
+
+  for (const token of argv) {
+    if (!parsingOptions && !token.startsWith('--')) {
+      commandTokens.push(token);
+      continue;
+    }
+
+    parsingOptions = true;
+    rest.push(token);
+  }
+
+  const command = commandTokens.join(' ');
+  const options = {};
+
+  for (let index = 0; index < rest.length; index += 1) {
+    const token = rest[index];
+    if (!token.startsWith('--')) {
+      continue;
+    }
+
+    const key = token.slice(2);
+    const next = rest[index + 1];
+    if (next === undefined || next.startsWith('--')) {
+      options[key] = true;
+    } else {
+      options[key] = next;
+      index += 1;
+    }
+  }
+
+  return { command, options };
+}
+
+export async function runCli(argv, stdout, stderr) {
+  const { command, options } = parseArgs(argv);
+  const normalizedCommand = ({
+    'sessions list': 'session-insights',
+    'sessions show': 'session-show',
+    'programs list': 'program-list',
+    'programs current': 'program-summary',
+    'exercises history': 'exercise-history',
+    'sessions compare': 'planned-vs-actual',
+    'sessions explain': 'why-did-this-change',
+    insights: 'session-insights',
+    history: 'exercise-history',
+    prs: 'records',
+    program: 'program-summary',
+    compare: 'planned-vs-actual',
+    explain: 'why-did-this-change'
+  })[command] ?? command;
+
+  if (!command) {
+    stderr.write('Usage: incremnt <sessions list|sessions show|sessions compare|sessions explain|programs list|programs current|exercises history|records|status|contract|login|logout> [options]\n');
+    return 1;
+  }
+
+  const sessionState = await readSessionState();
+  const transport = await createTransport(options, sessionState);
+
+  if (normalizedCommand === 'status') {
+    stdout.write(`${JSON.stringify({
+      contractVersion,
+      capabilities,
+      mode: transport.kind,
+      config: {
+        dir: resolveConfigDir(),
+        sessionPath: sessionState.path
+      },
+      auth: {
+        loggedIn: Boolean(sessionState.session),
+        sessionExists: sessionState.exists,
+        sessionSchemaVersion: sessionState.session?.version ?? null,
+        expired: isSessionExpired(sessionState.session),
+        error: sessionState.error,
+        account: sessionState.session?.account ?? null
+      },
+      remote: {
+        bootstrap: transport.kind === 'remote' ? transport.bootstrap ?? false : false,
+        source: transport.kind === 'remote' ? transport.source ?? null : null,
+        baseUrl: transport.kind === 'remote' ? transport.baseUrl ?? null : null,
+        contractVersion: transport.kind === 'remote' ? transport.contractVersion ?? null : null,
+        capabilities: transport.kind === 'remote' ? transport.capabilities ?? null : null,
+        fixturePath: transport.kind === 'remote' ? transport.fixturePath ?? null : null
+      },
+      snapshot: {
+        source: transport.snapshotSource?.source ?? null,
+        path: transport.snapshotSource?.path ?? null
+      }
+    }, null, 2)}\n`);
+    return 0;
+  }
+
+  if (normalizedCommand === 'contract') {
+    stdout.write(`${JSON.stringify({
+      contractVersion,
+      binary: 'incremnt',
+      capabilities,
+      officialCommands
+    }, null, 2)}\n`);
+    return 0;
+  }
+
+  if (normalizedCommand === 'logout') {
+    try {
+      const result = await clearSessionState();
+      stdout.write(`${JSON.stringify({
+        ok: true,
+        cleared: result.cleared,
+        sessionPath: result.path
+      }, null, 2)}\n`);
+      return 0;
+    } catch (error) {
+      stderr.write(`${error.message}\n`);
+      return 1;
+    }
+  }
+
+  if (normalizedCommand === 'login') {
+    const loginBaseUrl = resolveLoginBaseUrl(options, sessionState);
+
+    if (loginBaseUrl) {
+      if (options.token && options.email) {
+        stderr.write('Pass either --token or --email with --base-url, not both\n');
+        return 1;
+      }
+
+      if (!options.token && !options.email) {
+        try {
+          const authConfig = await fetchRemoteAuthConfig(loginBaseUrl);
+          const result = await bootstrapSessionFromRemoteBaseUrlWithDeviceFlow(loginBaseUrl, {
+            authConfig,
+            onChallenge: async (challenge, auth) => {
+              const baseUrlNormalized = loginBaseUrl.replace(/\/$/, '');
+              const userCodeParam = encodeURIComponent(challenge.userCode);
+              const providers = configuredAuthProviders(auth);
+
+              // Skip the approval form and go straight to the provider when there's exactly one
+              let verificationUrl;
+              if (providers.length === 1 && auth?.providers?.apple?.configured) {
+                verificationUrl = `${baseUrlNormalized}/auth/apple/start?userCode=${userCodeParam}`;
+              } else if (providers.length === 1 && auth?.providers?.google?.configured) {
+                verificationUrl = `${baseUrlNormalized}/auth/google/start?userCode=${userCodeParam}`;
+              } else {
+                verificationUrl = `${baseUrlNormalized}${challenge.verificationUri ?? '/auth/device/approve'}?userCode=${userCodeParam}`;
+              }
+
+              stderr.write('Signing in...\n');
+              const opened = await maybeOpenBrowser(verificationUrl);
+              if (opened) {
+                stderr.write('Opened your browser to sign in.\n');
+              } else {
+                stderr.write(`Open this URL to sign in: ${verificationUrl}\n`);
+              }
+              if (providers.length > 1) {
+                stderr.write(`Continue with one of: ${providers.join(', ')}.\n`);
+              } else if (providers.length === 0) {
+                stderr.write('If you are using the local dev sync service, run its approve-device helper with that code.\n');
+              }
+            }
+          });
+          stdout.write(`${JSON.stringify({
+            ok: true,
+            sessionPath: result.path,
+            account: result.session.account,
+            remoteContractVersion: result.session.transport?.contractVersion ?? null,
+            transport: result.session.transport
+          }, null, 2)}\n`);
+          return 0;
+        } catch (error) {
+          stderr.write(`${error.message}\n`);
+          return 1;
+        }
+      }
+
+      if (options.email) {
+        try {
+          const result = await bootstrapSessionFromRemoteBaseUrlWithEmail(loginBaseUrl, options.email, options['user-id']);
+          stdout.write(`${JSON.stringify({
+            ok: true,
+            sessionPath: result.path,
+            account: result.session.account,
+            remoteContractVersion: result.session.transport?.contractVersion ?? null,
+            transport: result.session.transport
+          }, null, 2)}\n`);
+          return 0;
+        } catch (error) {
+          stderr.write(`${error.message}\n`);
+          return 1;
+        }
+      }
+
+      try {
+        const result = await bootstrapSessionFromRemoteBaseUrl(loginBaseUrl, options.token);
+        stdout.write(`${JSON.stringify({
+          ok: true,
+          sessionPath: result.path,
+          account: result.session.account,
+          remoteContractVersion: result.session.transport?.contractVersion ?? null,
+          transport: result.session.transport
+        }, null, 2)}\n`);
+        return 0;
+      } catch (error) {
+        stderr.write(`${error.message}\n`);
+        return 1;
+      }
+    }
+
+    if (options.snapshot) {
+      try {
+        const result = await bootstrapSessionFromSnapshot(options.snapshot);
+        stdout.write(`${JSON.stringify({
+          ok: true,
+          sessionPath: result.path,
+          account: result.session.account,
+          transport: result.session.transport
+        }, null, 2)}\n`);
+        return 0;
+      } catch (error) {
+        stderr.write(`${error.message}\n`);
+        return 1;
+      }
+    }
+
+    if (options['session-file']) {
+      try {
+        const result = await importSessionFile(options['session-file']);
+        stdout.write(`${JSON.stringify({
+          ok: true,
+          sessionPath: result.path,
+          account: result.session.account
+        }, null, 2)}\n`);
+        return 0;
+      } catch (error) {
+        stderr.write(`${error.message}\n`);
+        return 1;
+      }
+    }
+
+    stderr.write('Pass --base-url, --snapshot, or --session-file to login, or set INCREMNT_BASE_URL.\n');
+    return 1;
+  }
+
+  if (!readCommands.has(normalizedCommand)) {
+    stderr.write(`Unknown command: ${command}\n`);
+    return 1;
+  }
+
+  try {
+    const payload = await transport.executeReadCommand(normalizedCommand, options);
+    const pretty = options.pretty ? formatPretty(normalizedCommand, payload) : null;
+    stdout.write(pretty ? `${pretty}\n` : `${JSON.stringify(payload, null, 2)}\n`);
+    return 0;
+  } catch (error) {
+    stderr.write(`${error.message}\n`);
+    return 1;
+  }
+}
+
+function resolveLoginBaseUrl(options, sessionState) {
+  return options['base-url']
+    ?? process.env.INCREMNT_BASE_URL
+    ?? sessionState.session?.transport?.baseUrl
+    ?? null;
+}
+
+async function maybeOpenBrowser(url) {
+  if (process.env.INCREMNT_DISABLE_BROWSER === '1') {
+    return false;
+  }
+
+  if (process.env.INCREMNT_BROWSER_CAPTURE_FILE) {
+    await fs.writeFile(process.env.INCREMNT_BROWSER_CAPTURE_FILE, url);
+    return true;
+  }
+
+  const command = browserCommandForPlatform();
+  if (!command) {
+    return false;
+  }
+
+  try {
+    const child = spawn(command.bin, [...command.args, url], {
+      stdio: 'ignore',
+      detached: true
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function browserCommandForPlatform() {
+  if (process.platform === 'darwin') {
+    return { bin: 'open', args: [] };
+  }
+
+  if (process.platform === 'linux') {
+    return { bin: 'xdg-open', args: [] };
+  }
+
+  if (process.platform === 'win32') {
+    return { bin: 'cmd', args: ['/c', 'start', ''] };
+  }
+
+  return null;
+}
+
+function configuredAuthProviders(auth) {
+  const providers = auth?.providers ?? {};
+  const labels = [];
+
+  if (providers.apple?.configured) {
+    labels.push('Apple');
+  }
+
+  if (providers.google?.configured) {
+    labels.push('Google');
+  }
+
+  return labels;
+}

package/src/local.js

@@ -0,0 +1,59 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+export async function readSnapshot(inputPath) {
+  const raw = await fs.readFile(inputPath, 'utf8');
+  return JSON.parse(raw);
+}
+
+async function mostRecentDownloadSnapshot() {
+  const downloadsDir = path.join(os.homedir(), 'Downloads');
+
+  try {
+    const entries = await fs.readdir(downloadsDir, { withFileTypes: true });
+    const matchingFiles = entries
+      .filter((entry) => entry.isFile() && /^onemore-developer-snapshot\.onemore(?: \d+)?\.json$/i.test(entry.name))
+      .map((entry) => path.join(downloadsDir, entry.name));
+
+    if (matchingFiles.length === 0) {
+      return null;
+    }
+
+    const withStats = await Promise.all(
+      matchingFiles.map(async (candidate) => ({
+        candidate,
+        stat: await fs.stat(candidate)
+      }))
+    );
+
+    return withStats
+      .sort((lhs, rhs) => rhs.stat.mtimeMs - lhs.stat.mtimeMs)[0]
+      .candidate;
+  } catch {
+    return null;
+  }
+}
+
+export async function resolveSnapshotSource(explicitPath) {
+  const downloadSnapshot = await mostRecentDownloadSnapshot();
+  const candidates = [
+    explicitPath ? { path: explicitPath, source: 'input' } : null,
+    process.env.INCREMNT_SNAPSHOT ? { path: process.env.INCREMNT_SNAPSHOT, source: 'env:INCREMNT_SNAPSHOT' } : null,
+    process.env.ONEMORE_SNAPSHOT ? { path: process.env.ONEMORE_SNAPSHOT, source: 'env:ONEMORE_SNAPSHOT' } : null,
+    { path: path.join(process.cwd(), 'onemore-developer-snapshot.onemore.json'), source: 'cwd' },
+    { path: path.join(os.homedir(), 'Library', 'Application Support', 'OneMore', 'onemore-developer-snapshot.onemore.json'), source: 'app-support' },
+    downloadSnapshot ? { path: downloadSnapshot, source: 'downloads' } : null
+  ].filter(Boolean);
+
+  for (const candidate of candidates) {
+    try {
+      await fs.access(candidate.path);
+      return candidate;
+    } catch {
+      // Try next candidate.
+    }
+  }
+
+  return null;
+}