@notis_ai/cli 0.2.0-beta.16.1 → 0.2.0-beta.160.1

package/src/runtime/auth-recovery.js

@@ -0,0 +1,110 @@
+import { CliError, EXIT_CODES } from './errors.js';
+import { channelFromProfile, cliCommandForChannel } from './channel.js';
+
+// Recovery is only useful when the printed command is the one that will run:
+// telling a beta profile to reinstall `@latest` sends it back to the build it
+// just failed on.
+function cliNpx(runtime = {}) {
+  return cliCommandForChannel(
+    runtime.channel || channelFromProfile({ api_base: runtime.apiBase }),
+  );
+}
+
+export function quoteShellArgument(value) {
+  return `'${String(value).replace(/'/g, `'"'"'`)}'`;
+}
+
+function profileSuffix(profileName) {
+  return profileName && profileName !== 'default'
+    ? ` --profile ${quoteShellArgument(profileName)}`
+    : '';
+}
+
+/**
+ * How to get an unusable profile back to a working credential.
+ *
+ * `mode` distinguishes the two cases a caller has to act on differently:
+ * "expired" means the profile holds a grant the browser can renew, while
+ * "missing" means this profile has never been authorized at all.
+ */
+export function getAuthRecovery(runtime = {}, { mode = 'expired' } = {}) {
+  const CLI_NPX = cliNpx(runtime);
+  const suffix = profileSuffix(runtime.profileName);
+  const hints = [
+    {
+      command: `${CLI_NPX} login${suffix}`,
+      reason: mode === 'missing'
+        ? 'Sign in or create an account in the browser and authorize this machine'
+        : 'Authorize a fresh scoped CLI credential for this profile',
+    },
+    {
+      command: `${CLI_NPX} profile list`,
+      reason: 'Check whether another profile on this machine is already signed in',
+    },
+    {
+      command: `${CLI_NPX} doctor${suffix}`,
+      reason: 'Retry the auth and API checks once authorization completes',
+    },
+  ];
+  return { hints };
+}
+
+export function createExpiredAuthError(runtime) {
+  const CLI_NPX = cliNpx(runtime || {});
+  if (runtime?.credentialKind === 'worktree') {
+    return new CliError({
+      code: 'auth_expired',
+      message: `The ./dev.sh credential for profile "${runtime.profileName}" has expired`,
+      exitCode: EXIT_CODES.auth,
+      details: { credential_source: 'worktree' },
+      hints: [
+        { message: 'Restart ./dev.sh in this worktree to mint a fresh dev credential.' },
+        {
+          command: `${CLI_NPX} profile list`,
+          reason: 'Switch to a live account profile instead of the dev one',
+        },
+      ],
+    });
+  }
+  if (runtime?.credentialSource === 'env') {
+    return new CliError({
+      code: 'auth_expired',
+      message: 'NOTIS_JWT is expired',
+      exitCode: EXIT_CODES.auth,
+      details: { credential_source: 'env' },
+      hints: [
+        {
+          command: 'Set NOTIS_JWT to a fresh token',
+          reason: 'The explicit environment credential overrides every stored profile',
+        },
+      ],
+    });
+  }
+
+  return new CliError({
+    code: 'auth_expired',
+    message: `Notis CLI authorization for profile "${runtime?.profileName || 'default'}" has expired`,
+    exitCode: EXIT_CODES.auth,
+    details: { credential_source: 'oauth' },
+    hints: getAuthRecovery(runtime).hints,
+  });
+}
+
+export function createInvalidAuthHints(runtime) {
+  if (runtime?.credentialKind === 'worktree') {
+    return [
+      {
+        message: 'Restart ./dev.sh in this worktree to mint a fresh dev credential.',
+      },
+    ];
+  }
+  if (runtime?.credentialSource === 'env') {
+    return [
+      {
+        command: 'Set NOTIS_JWT to a fresh token',
+        reason: 'The explicit environment credential was rejected',
+      },
+    ];
+  }
+  return getAuthRecovery(runtime || {}).hints;
+}

package/src/runtime/base-skills.d.ts

@@ -0,0 +1,20 @@
+export interface BaseSkillReconcileResult {
+  installed: number;
+  linked: number;
+  unchanged: number;
+  backups: string[];
+  skills: string[];
+}
+
+export const BASE_SKILL_NAMES: readonly string[];
+
+export function resolveBundledBaseSkillsRoot(options?: {
+  resourcesPath?: string;
+}): string;
+
+export function reconcileBaseSkills(options?: {
+  home?: string;
+  userId?: string | null;
+  sourceRoot?: string;
+  now?: number;
+}): BaseSkillReconcileResult;

package/src/runtime/base-skills.js

@@ -0,0 +1,167 @@
+import {
+  cpSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readlinkSync,
+  renameSync,
+  rmSync,
+  symlinkSync,
+} from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const BASE_SKILL_NAMES = Object.freeze([
+  'notis-apps',
+  'notis-query',
+  'notis-cli',
+]);
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+
+export function resolveBundledBaseSkillsRoot({ resourcesPath = process.resourcesPath } = {}) {
+  const sourceCheckout = resolve(HERE, '../../../../server/skills');
+  const packaged = resolve(HERE, '../../dist/base-skills');
+  const desktopResource = resourcesPath ? join(resourcesPath, 'base-skills') : null;
+  // Electron Packager copies each extraResource directory under its basename,
+  // so the three skill folders sit directly in process.resourcesPath.
+  const desktopPackagerRoot = resourcesPath || null;
+  for (const candidate of [sourceCheckout, packaged, desktopResource, desktopPackagerRoot]) {
+    if (
+      candidate
+      && BASE_SKILL_NAMES.every((name) => existsSync(join(candidate, name, 'SKILL.md')))
+    ) {
+      return candidate;
+    }
+  }
+  return packaged;
+}
+
+export function getBaseSkillPaths({ home = homedir(), userId = null } = {}) {
+  const notisRoot = join(home, '.notis', 'skills');
+  const targetRoots = [
+    join(home, '.agents', 'skills'),
+    join(home, '.codex', 'skills'),
+    join(home, '.cursor', 'skills'),
+    join(home, '.claude', 'skills'),
+  ];
+  if (userId) {
+    targetRoots.push(join(notisRoot, 'users', userId, 'skills'));
+  }
+  return {
+    baseRoot: join(notisRoot, 'base'),
+    backupRoot: join(notisRoot, 'backups'),
+    targetRoots,
+  };
+}
+
+function sameLinkTarget(linkPath, expectedTarget) {
+  try {
+    if (!lstatSync(linkPath).isSymbolicLink()) return false;
+    return resolve(dirname(linkPath), readlinkSync(linkPath)) === resolve(expectedTarget);
+  } catch {
+    return false;
+  }
+}
+
+function backupConflict(linkPath, backupRoot, targetLabel, skillName, now) {
+  const backupPath = join(backupRoot, String(now), targetLabel, skillName);
+  mkdirSync(dirname(backupPath), { recursive: true, mode: 0o700 });
+  renameSync(linkPath, backupPath);
+  return backupPath;
+}
+
+function replaceDirectory(source, destination) {
+  mkdirSync(dirname(destination), { recursive: true, mode: 0o700 });
+  const temporary = `${destination}.tmp-${process.pid}-${Date.now()}`;
+  const previous = `${destination}.previous-${process.pid}-${Date.now()}`;
+  rmSync(temporary, { recursive: true, force: true });
+  cpSync(source, temporary, { recursive: true });
+  let movedPrevious = false;
+  try {
+    if (existsSync(destination)) {
+      renameSync(destination, previous);
+      movedPrevious = true;
+    }
+    renameSync(temporary, destination);
+    if (movedPrevious) rmSync(previous, { recursive: true, force: true });
+  } catch (error) {
+    rmSync(temporary, { recursive: true, force: true });
+    if (movedPrevious && !existsSync(destination) && existsSync(previous)) {
+      renameSync(previous, destination);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Install the three CLI-owned system skills and expose them to every supported
+ * local agent. This intentionally does not consult the account sync setting:
+ * that setting controls only Electron's repeating account-skill refresh.
+ */
+export function reconcileBaseSkills({
+  home = homedir(),
+  userId = null,
+  sourceRoot = resolveBundledBaseSkillsRoot(),
+  now = Date.now(),
+} = {}) {
+  const paths = getBaseSkillPaths({ home, userId });
+  const result = {
+    installed: 0,
+    linked: 0,
+    unchanged: 0,
+    backups: [],
+    skills: [...BASE_SKILL_NAMES],
+  };
+
+  for (const name of BASE_SKILL_NAMES) {
+    const source = join(sourceRoot, name);
+    if (!existsSync(join(source, 'SKILL.md'))) {
+      throw new Error(`Bundled base skill is missing: ${name}`);
+    }
+    replaceDirectory(source, join(paths.baseRoot, name));
+    result.installed += 1;
+  }
+
+  for (const targetRoot of paths.targetRoots) {
+    mkdirSync(targetRoot, { recursive: true, mode: 0o700 });
+    const targetLabel = relative(home, targetRoot).replaceAll('/', '_') || 'home';
+    for (const name of BASE_SKILL_NAMES) {
+      const skillTarget = join(paths.baseRoot, name);
+      const linkPath = join(targetRoot, name);
+      if (sameLinkTarget(linkPath, skillTarget)) {
+        result.unchanged += 1;
+        continue;
+      }
+      if (existsSync(linkPath) || (() => {
+        try { lstatSync(linkPath); return true; } catch { return false; }
+      })()) {
+        // sameLinkTarget already accepted links owned by this installer. Every
+        // other path, including a user-created symlink, is a conflict whose
+        // identity and target must remain recoverable.
+        result.backups.push(backupConflict(linkPath, paths.backupRoot, targetLabel, name, now));
+      }
+      const relativeTarget = relative(targetRoot, skillTarget) || '.';
+      symlinkSync(
+        process.platform === 'win32' ? skillTarget : relativeTarget,
+        linkPath,
+        process.platform === 'win32' ? 'junction' : undefined,
+      );
+      result.linked += 1;
+    }
+  }
+
+  return result;
+}
+
+export function reconcileBaseSkillsBestEffort(options = {}) {
+  try {
+    return reconcileBaseSkills(options);
+  } catch (error) {
+    if (process.env.NOTIS_DEBUG_BASE_SKILLS === '1') {
+      process.stderr.write(`[notis] Base skill reconciliation failed: ${error.message}\n`);
+    }
+    return null;
+  }
+}

package/src/runtime/channel.js

@@ -0,0 +1,133 @@
+/**
+ * Which published CLI build a profile should run.
+ *
+ * The npm tag has to be chosen before the CLI starts, and the CLI only learns
+ * which Notis it talks to after it reads the profile — so a single documented
+ * install command can never be right for both environments on its own. The
+ * deployment answers the question at login (`notis_cli_channel` in the CLI
+ * protected-resource metadata), the answer is pinned on the profile, and every
+ * later run re-executes the matching build. `@notis_ai/cli@latest` therefore
+ * stays the one command worth documenting, including for beta accounts.
+ */
+
+export const RELEASE_CHANNELS = ['stable', 'beta'];
+const CHANNEL_TAGS = { stable: 'latest', beta: 'beta' };
+export const CLI_PACKAGE_NAME = '@notis_ai/cli';
+// Set on the child so a build that disagrees about its own channel — a bad
+// version string, a half-published tag — cannot bounce the process forever.
+export const CHANNEL_SWITCH_ENV = 'NOTIS_CLI_CHANNEL_SWITCHED';
+export const CHANNEL_DISABLE_ENV = 'NOTIS_CLI_AUTO_CHANNEL';
+
+export function isReleaseChannel(value) {
+  return RELEASE_CHANNELS.includes(value);
+}
+
+export function packageTagForChannel(channel) {
+  return CHANNEL_TAGS[channel] || CHANNEL_TAGS.stable;
+}
+
+export function cliCommandForChannel(channel) {
+  return `npx --package ${CLI_PACKAGE_NAME}@${packageTagForChannel(channel)} -- notis`;
+}
+
+/**
+ * The channel of the build that is currently running.
+ *
+ * The publish pipeline stamps beta releases as prereleases
+ * (`0.2.0-beta.129.1`) and production releases as plain semver (`0.2.10`), so
+ * the manifest version is the only channel marker that cannot drift from what
+ * npm actually served.
+ */
+export function channelFromVersion(version) {
+  return String(version || '').includes('-') ? 'beta' : 'stable';
+}
+
+/**
+ * The channel a profile is pinned to.
+ *
+ * `channel` is written at login from the deployment's own metadata. The
+ * `beta` flag and the endpoint host are the fallbacks that let a profile
+ * authorized by an older CLI resolve without a second login.
+ */
+export function channelFromProfile(profile = {}) {
+  if (isReleaseChannel(profile.channel)) {
+    return profile.channel;
+  }
+  if (profile.beta === true) return 'beta';
+  if (profile.beta === false) return 'stable';
+  for (const candidate of [profile.oauth_api_base, profile.api_base]) {
+    if (typeof candidate !== 'string' || !candidate) continue;
+    try {
+      const { hostname } = new URL(candidate);
+      if (hostname === 'api-beta.notis.ai') return 'beta';
+      if (hostname === 'api.notis.ai') return 'stable';
+    } catch {
+      // A malformed endpoint says nothing about the channel.
+    }
+  }
+  return null;
+}
+
+/**
+ * A profile served by `./dev.sh` runs the CLI from that worktree on purpose.
+ * Re-executing it into a published build would swap both the code under test
+ * and the credential the worktree minted.
+ */
+export function isDevManagedProfile(profile = {}) {
+  if (profile.dev_access_token || profile.dev_workspace_root) {
+    return true;
+  }
+  if (typeof profile.api_base !== 'string' || !profile.api_base) {
+    return false;
+  }
+  try {
+    const { hostname } = new URL(profile.api_base);
+    return ['localhost', '127.0.0.1', '::1', '[::1]'].includes(hostname);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * A checkout run through `node bin/notis.js` is someone testing this source
+ * tree. Only an installed copy — one that npm placed under node_modules — may
+ * hand its invocation to a different published build.
+ */
+export function isInstalledPackage(moduleDirectory) {
+  return String(moduleDirectory || '').split(/[\\/]/).includes('node_modules');
+}
+
+/**
+ * Decide whether this process should hand over to another published build.
+ *
+ * Returns the reason in every case: the caller reports it under `--verbose`
+ * and the tests assert on it, so a switch that silently does not happen is
+ * still explainable.
+ */
+export function resolveChannelSwitch({
+  runningVersion,
+  profile = {},
+  moduleDirectory = '',
+  env = process.env,
+  platform = process.platform,
+} = {}) {
+  const runningChannel = channelFromVersion(runningVersion);
+  const targetChannel = channelFromProfile(profile);
+  const stay = (reason) => ({ switch: false, reason, runningChannel, targetChannel });
+
+  if (env[CHANNEL_SWITCH_ENV] === '1') return stay('already_switched');
+  if (env[CHANNEL_DISABLE_ENV] === '0') return stay('disabled');
+  if (!targetChannel) return stay('profile_channel_unknown');
+  if (targetChannel === runningChannel) return stay('channel_matches');
+  if (isDevManagedProfile(profile)) return stay('dev_managed_profile');
+  if (!isInstalledPackage(moduleDirectory)) return stay('source_checkout');
+
+  return {
+    switch: true,
+    reason: 'channel_mismatch',
+    runningChannel,
+    targetChannel,
+    command: platform === 'win32' ? 'npx.cmd' : 'npx',
+    args: ['--yes', '--package', `${CLI_PACKAGE_NAME}@${packageTagForChannel(targetChannel)}`, '--', 'notis'],
+  };
+}

package/src/runtime/delegated-context.js

@@ -0,0 +1,68 @@
+/**
+ * Detect that this CLI is running *as* a Notis agent rather than for a person.
+ *
+ * Hand-over is the one command where that distinction matters: an agent Notis
+ * is already running has no business handing the same work back to Notis, and
+ * nothing about the loop it would create is self-limiting.
+ *
+ * This is the polite half of the guard. The server refuses the same call unless
+ * it carries a purpose-scoped CLI/MCP OAuth token, which a delegated runtime
+ * never has -- that is the half that actually holds. What this adds is a clear
+ * message at the point of the mistake, instead of a permission error the agent
+ * will try to work around.
+ */
+
+import { existsSync } from 'node:fs';
+import { CliError, EXIT_CODES } from './errors.js';
+
+// The cloud computer's root. Present only inside the user's Vercel sandbox.
+const SANDBOX_ROOT = '/vercel/sandbox';
+
+export function delegatedContextReason(env = process.env, { fileExists = existsSync } = {}) {
+  if (env.NOTIS_DELEGATED_CONTEXT === '1') {
+    // Set by Notis Desktop on every coding agent it spawns. Those runs use the
+    // user's own OAuth profile, so nothing else distinguishes them.
+    return 'this process was started by Notis as a delegated coding agent';
+  }
+  if (fileExists(SANDBOX_ROOT)) {
+    return 'this process is running on the Notis cloud computer';
+  }
+  if (env.NOTIS_AGENT === '1' && env.NOTIS_JWT) {
+    return 'this process is authenticated as a Notis agent, not as you';
+  }
+  return null;
+}
+
+export function assertNotDelegated(commandLabel, env = process.env) {
+  const reason = delegatedContextReason(env);
+  if (!reason) {
+    return;
+  }
+  throw new CliError({
+    code: 'handover_from_delegated_context',
+    message:
+      `\`notis ${commandLabel}\` hands work to a Notis agent, and ${reason}. ` +
+      'An agent cannot hand its own task back to Notis.',
+    exitCode: EXIT_CODES.usage,
+    hints: [
+      { message: 'Run the hand-over from the terminal on your own machine.' },
+      { message: 'If you are the agent: just do the work here, in this workspace.' },
+    ],
+  });
+}
+
+/**
+ * Tools that hand work to a Notis agent, by canonical name.
+ *
+ * `notis handover` is not the only way to reach these: `notis tools exec` takes
+ * any tool name, and `tools exec-parallel` takes a list of them. Guarding only
+ * the friendly command would leave the escape hatch it exists to wrap.
+ */
+export const HANDOVER_TOOL_NAMES = new Set(['LOCAL_NOTIS_HAND_OVER']);
+
+export function assertToolNotDelegated(toolName, env = process.env) {
+  if (!HANDOVER_TOOL_NAMES.has(String(toolName || '').toUpperCase())) {
+    return;
+  }
+  assertNotDelegated(`tools exec ${toolName}`, env);
+}

package/src/runtime/errors.js

@@ -6,6 +6,7 @@ export const EXIT_CODES = {
   conflict: 5,
   backend: 6,
   unexpected: 7,
+  payment: 8,
 };
 
 export class CliError extends Error {