@notis_ai/cli 0.2.0-beta.19.1 → 0.2.0-beta.196.1

package/src/runtime/git.js

@@ -0,0 +1,233 @@
+/**
+ * Local git inspection for `notis handover`.
+ *
+ * The CLI has no other reason to know about git, so this stays deliberately
+ * small: read where we are, push the branch, and report what the remote is.
+ * Everything else about the repository is the cloud workspace's problem.
+ *
+ * Every call is `spawnSync` on the real `git` binary rather than a library.
+ * The user's credentials, hooks, SSH agent and includeIf config are what make a
+ * push succeed on their machine, and only their own git honors all of them.
+ */
+
+import { spawnSync } from 'node:child_process';
+import { lstatSync, readFileSync } from 'node:fs';
+import { basename, relative, resolve, sep } from 'node:path';
+import { CliError, EXIT_CODES } from './errors.js';
+
+const GIT_TIMEOUT_MS = 120_000;
+const MAX_SECRET_SCAN_BYTES = 1_000_000;
+const SAFE_ENV_TEMPLATES = /^\.env\.(?:example|sample|template)$/i;
+const SENSITIVE_PATH = /^(?:\.env(?:\..+)?|\.envrc|\.git-credentials|\.npmrc|\.pypirc|\.netrc|credentials(?:\..+)?|secrets?(?:\..+)?|id_(?:rsa|dsa|ecdsa|ed25519)(?:\.pub)?|.*\.(?:pem|key|p12|pfx|jks))$/i;
+const SENSITIVE_CONTENT = [
+  /-----BEGIN (?:RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/,
+  /\b[a-z][a-z0-9+.-]*:\/\/[^/\s:@]+:[^/\s@]+@/i,
+  /\bAKIA[0-9A-Z]{16}\b/,
+  /\bgh[pousr]_[A-Za-z0-9]{36,}\b/,
+  /\bsk-[A-Za-z0-9_-]{20,}\b/,
+];
+
+export function runGit(
+  args,
+  { cwd = process.cwd(), timeoutMs = GIT_TIMEOUT_MS, trimOutput = true } = {},
+) {
+  const result = spawnSync('git', args, {
+    cwd,
+    encoding: 'utf8',
+    timeout: timeoutMs,
+    env: {
+      ...process.env,
+      // A push that stops to ask for a password would hang a non-interactive
+      // agent run forever. Fail fast instead and let the hint explain.
+      GIT_TERMINAL_PROMPT: '0',
+    },
+  });
+  if (result.error && result.error.code === 'ENOENT') {
+    throw new CliError({
+      code: 'git_not_found',
+      message: 'git is not installed or not on PATH.',
+      exitCode: EXIT_CODES.usage,
+    });
+  }
+  return {
+    exitCode: result.status ?? 1,
+    stdout: trimOutput ? (result.stdout || '').trim() : (result.stdout || ''),
+    stderr: trimOutput ? (result.stderr || '').trim() : (result.stderr || ''),
+  };
+}
+
+function gitOrNull(args, options) {
+  const result = runGit(args, options);
+  return result.exitCode === 0 ? result.stdout : null;
+}
+
+function nulSeparatedGitPaths(args, repository) {
+  const result = runGit([...args, '-z'], { cwd: repository.toplevel, trimOutput: false });
+  if (result.exitCode !== 0 || !result.stdout) return [];
+  return result.stdout.split('\0').filter(Boolean);
+}
+
+/** Exact files `git add -A` would include, expanding untracked directories. */
+function filesToAutoCommit(repository) {
+  return [...new Set([
+    ...nulSeparatedGitPaths(['diff', '--name-only'], repository),
+    ...nulSeparatedGitPaths(['diff', '--cached', '--name-only'], repository),
+    ...nulSeparatedGitPaths(['ls-files', '--others', '--exclude-standard'], repository),
+  ])];
+}
+
+/** Refuse files that are unsafe to publish automatically without user review. */
+export function sensitiveAutoCommitFiles(repository) {
+  const root = resolve(repository.toplevel);
+  const sensitive = [];
+  for (const path of filesToAutoCommit(repository)) {
+    const absolute = resolve(root, path);
+    const insideRoot = relative(root, absolute);
+    if (insideRoot === '..' || insideRoot.startsWith(`..${sep}`) || insideRoot === '') continue;
+    const name = basename(path);
+    if (SENSITIVE_PATH.test(name) && !SAFE_ENV_TEMPLATES.test(name)) {
+      sensitive.push(path);
+      continue;
+    }
+    try {
+      const stat = lstatSync(absolute);
+      if (!stat.isFile() || stat.size > MAX_SECRET_SCAN_BYTES) continue;
+      const content = readFileSync(absolute, 'utf8');
+      if (SENSITIVE_CONTENT.some((pattern) => pattern.test(content))) sensitive.push(path);
+    } catch {
+      // Deleted files and paths racing with an editor have no content to leak.
+    }
+  }
+  return sensitive;
+}
+
+/**
+ * Parse an origin URL into {owner, repo}. Handles the three forms git remotes
+ * actually take: scp-style ssh, ssh:// and https://.
+ */
+export function parseRemoteUrl(url) {
+  if (typeof url !== 'string' || !url) {
+    return null;
+  }
+  const trimmed = url.trim().replace(/\.git$/, '');
+  const scp = trimmed.match(/^[^@]+@([^:]+):(.+)$/);
+  const path = scp ? scp[2] : trimmed.replace(/^[a-z+]+:\/\/(?:[^@/]+@)?[^/]+\//i, '');
+  const host = scp ? scp[1] : (trimmed.match(/^[a-z+]+:\/\/(?:[^@/]+@)?([^/]+)/i) || [])[1];
+  const segments = path.split('/').filter(Boolean);
+  if (segments.length < 2) {
+    return null;
+  }
+  return {
+    host: host || null,
+    owner: segments[segments.length - 2],
+    repo: segments[segments.length - 1],
+  };
+}
+
+/** Everything `handover start` needs to know about where it is running. */
+export function inspectRepository(cwd = process.cwd()) {
+  const toplevel = gitOrNull(['rev-parse', '--show-toplevel'], { cwd });
+  if (!toplevel) {
+    throw new CliError({
+      code: 'not_a_git_repository',
+      message: 'Hand-over runs from inside a git repository.',
+      exitCode: EXIT_CODES.usage,
+      hints: [{ message: 'cd into the repository you want Notis to work on, then run the command again.' }],
+    });
+  }
+
+  const branch = gitOrNull(['branch', '--show-current'], { cwd: toplevel });
+  if (!branch) {
+    throw new CliError({
+      code: 'detached_head',
+      message: 'HEAD is detached, so there is no branch to hand over.',
+      exitCode: EXIT_CODES.usage,
+      hints: [{ message: 'Check out a branch first: git switch -c my-feature' }],
+    });
+  }
+
+  const remoteUrl = gitOrNull(['remote', 'get-url', 'origin'], { cwd: toplevel });
+  if (!remoteUrl) {
+    throw new CliError({
+      code: 'no_origin_remote',
+      message: 'This repository has no "origin" remote, so the cloud agent cannot fetch the branch.',
+      exitCode: EXIT_CODES.usage,
+      hints: [{ message: 'Add one: git remote add origin <url>' }],
+    });
+  }
+
+  const status = runGit(['status', '--porcelain'], { cwd: toplevel });
+  const dirtyFiles = status.stdout
+    ? status.stdout.split('\n').map((line) => line.slice(3).trim()).filter(Boolean)
+    : [];
+
+  return {
+    toplevel,
+    branch,
+    remoteUrl,
+    remote: parseRemoteUrl(remoteUrl),
+    dirtyFiles,
+    head: gitOrNull(['rev-parse', 'HEAD'], { cwd: toplevel }),
+    upstream: gitOrNull(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'], {
+      cwd: toplevel,
+    }),
+  };
+}
+
+/** Commit everything in the working tree, including untracked files. */
+export function commitWorkingTree(repository, message) {
+  const sensitiveFiles = sensitiveAutoCommitFiles(repository);
+  if (sensitiveFiles.length) {
+    throw new CliError({
+      code: 'sensitive_working_tree',
+      message: 'Refusing to publish files that may contain credentials or private keys.',
+      exitCode: EXIT_CODES.conflict,
+      details: { sensitive_files: sensitiveFiles.slice(0, 20) },
+      hints: [
+        { message: 'Review, remove, or ignore these files before handing over.' },
+        { message: 'To publish them deliberately, commit and push them yourself first.' },
+      ],
+    });
+  }
+  const add = runGit(['add', '-A'], { cwd: repository.toplevel });
+  if (add.exitCode !== 0) {
+    throw new CliError({
+      code: 'git_add_failed',
+      message: `Could not stage the working tree: ${add.stderr || add.stdout}`,
+      exitCode: EXIT_CODES.unexpected,
+    });
+  }
+  const commit = runGit(['commit', '-m', message], { cwd: repository.toplevel });
+  if (commit.exitCode !== 0) {
+    throw new CliError({
+      code: 'git_commit_failed',
+      message: `Could not commit the working tree: ${commit.stderr || commit.stdout}`,
+      exitCode: EXIT_CODES.unexpected,
+      hints: [{ message: 'Commit the changes yourself, then run the hand-over again.' }],
+    });
+  }
+  return gitOrNull(['rev-parse', 'HEAD'], { cwd: repository.toplevel });
+}
+
+/**
+ * Push the branch to origin. The cloud workspace fetches from origin, so an
+ * unpushed commit simply does not exist as far as the hand-over is concerned.
+ */
+export function pushBranch(repository, branch) {
+  const args = repository.upstream
+    ? ['push', 'origin', branch]
+    : ['push', '--set-upstream', 'origin', branch];
+  const result = runGit(args, { cwd: repository.toplevel });
+  if (result.exitCode !== 0) {
+    throw new CliError({
+      code: 'git_push_failed',
+      message: `Could not push ${branch} to origin: ${result.stderr || result.stdout}`,
+      exitCode: EXIT_CODES.conflict,
+      hints: [
+        { message: 'The cloud agent works from origin, so the branch has to be pushed first.' },
+        { message: 'If the remote moved ahead, reconcile locally (git pull --rebase) and retry.' },
+      ],
+    });
+  }
+  return true;
+}

package/src/runtime/login-listener.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+// Entry point for the detached process that owns an OAuth loopback callback.
+//
+// Spawned by `notis login` / `notis start` whenever the calling process cannot
+// wait for the browser itself — an agent reads a command's output only after it
+// exits, so the command has to return the authorization URL while something
+// else keeps listening. Never run this by hand: it takes a single argument, the
+// path to a short-lived payload file the parent wrote and this process deletes.
+import { runDetachedLoginListener } from './oauth.js';
+
+process.exitCode = await runDetachedLoginListener(
+  process.argv[2],
+  undefined,
+  process.argv[3],
+);

package/src/runtime/native-record-files.js

@@ -0,0 +1,47 @@
+import { open } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { basename, extname } from 'node:path';
+import { httpRequest } from './transport.js';
+import { usageError } from './errors.js';
+
+const MAX_BYTES = 8 * 1024 * 1024;
+const UUID = /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i;
+const MIME = { '.html': 'text/html', '.htm': 'text/html', '.txt': 'text/plain', '.md': 'text/markdown',
+  '.json': 'application/json', '.pdf': 'application/pdf', '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp' };
+
+/** Reads a bounded local file, never interprets it and never attaches it to a row. */
+export async function uploadNativeRecordFileWithCliRuntime({ runtime, target, recordKey, schemaRevision, requestId,
+  filePath, name = basename(filePath || ''), contentType = MIME[extname(filePath || '').toLowerCase()] || 'application/octet-stream',
+  signal, request = httpRequest }) {
+  if (!UUID.test(recordKey || '') || !UUID.test(requestId || '') || !Number.isSafeInteger(schemaRevision) || schemaRevision < 0
+    || !target || typeof target !== 'object' || Array.isArray(target) || !filePath) {
+    throw usageError('Choose a local file, native target, record key, schema revision and stable request ID.');
+  }
+  const handle = await open(filePath, 'r');
+  let data;
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile() || stat.size < 1 || stat.size > MAX_BYTES) throw usageError('Choose a regular file up to 8 MB.');
+    const buffer = Buffer.alloc(MAX_BYTES + 1);
+    let length = 0;
+    while (length < buffer.length) {
+      const read = await handle.read(buffer, length, buffer.length - length, length);
+      if (!read.bytesRead) break;
+      length += read.bytesRead;
+    }
+    if (!length || length > MAX_BYTES) throw usageError('Choose a file up to 8 MB.');
+    data = buffer.subarray(0, length);
+  } finally { await handle.close(); }
+  const digest = createHash('sha256').update(data).digest('hex');
+  const body = { protocol: 1, target, record_key: recordKey, schema_revision: schemaRevision, request_id: requestId,
+    name, content_type: contentType, base64: data.toString('base64') };
+  // No automatic retry: repeating this command with the same request ID is the
+  // exact immutable intent; a mismatched request fails instead of overwriting.
+  const result = (await request({ runtime, method: 'POST', path: '/portal_native_files/upload', spacesProtocol: 1, body, signal })).payload;
+  if (result?.protocol !== 1 || result.record_key !== recordKey || result.request_id !== requestId
+    || result.sha256 !== digest || result.size_bytes !== data.length || result.file?.name !== name
+    || typeof result.file?.url !== 'string' || !/^https?:\/\//.test(result.file.url) || result.url !== result.file.url) {
+    throw usageError('The file upload is not confirmed. Repeat the same request ID and file bytes.');
+  }
+  return result;
+}