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

package/dist/view-renderer/src/host.tsx

@@ -131,9 +131,11 @@ async function start() {
     captureContextSelection() {}, registerTopBarSearch() {}, setTopBarSearchValue() {}, setTopBarSearchLoading() {},
     publishActiveResource(value) { activeMarkdown = value?.snapshot?.format === 'markdown' && typeof value.snapshot.content === 'string' ? value.snapshot.content : null; },
     // The document page renders as its read-only snapshot: no toolbar, live session or saves.
+    // A note opened with the HTML viewer shows its one stored HTML file, never the editor.
     ui: { DocumentEditor, RecordProperties, HtmlFrame, ReportFrame, ShareControl: () => null,
-      DocumentPage: ({ recordKey, className, header, properties }) => <DocumentEditor recordKey={recordKey} className={className}
-        variant={header === false ? 'body' : 'full'} showProperties={properties !== 'hidden'} />,
+      DocumentPage: ({ recordKey, className, header, properties, viewer }) => viewer === 'html'
+        ? <HtmlFrame recordKey={recordKey} className={className} />
+        : <DocumentEditor recordKey={recordKey} className={className} variant={header === false ? 'body' : 'full'} showProperties={properties !== 'hidden'} />,
       MarkdownEditor: ({ value }) => <Markdown value={value} /> },
     callAction(id, inputs = {}) {
       if (!Object.hasOwn(authority.actions, id) || authority.actions[id].readOnly !== true) return denied();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@notis_ai/cli",
-  "version": "0.2.0-beta.196.1",
+  "version": "0.2.0-beta.198.1",
   "description": "Agent-first Notis CLI for apps and generic tool execution",
   "type": "module",
   "bin": {

package/skills/notis-apps/cli.md

@@ -20,7 +20,7 @@ or no-deploy requests stop at local artifacts without remote mutation. Store pub
 
 ## Reports and HTML
 
-New reports are independent Space views. Existing database report payloads render inside their database's main view. Use the installed HTML Space's saving Skill for self-contained HTML. See the canonical product guidance for build, revision, native file and view-link rules.
+Interactive reports are independent Space views. Save self-contained HTML pages and reports in Notis Notes with its Save HTML Skill; pages and reports saved before Spaces open there too. See the canonical product guidance for build, revision, native file and view-link rules.
 
 ## Commands
 

package/skills/notis-cli/AGENT_INSTRUCTIONS.md

@@ -15,7 +15,7 @@ Relevant Notis long-term memory may be injected into a turn inside `<notis_relev
 4. Execute: `notis tools exec <TOOL> --arguments '<json>'`; batch independent calls with `notis tools exec-parallel '<json-array>'`.
 5. If an integration is not connected, `notis tools link <toolkit>` prints a connection URL to give the user.
 
-Tool name shapes: `LOCAL_NOTIS_*` (native Notis), `LOCAL_NOTIS_DATABASE_*` (databases and notes), `LOCAL_MCP_*` (the user's connected MCP servers), and integration tools such as `GMAIL_*`, `NOTION_*`, and `GOOGLECALENDAR_*`.
+Tool name shapes: `LOCAL_NOTIS_*` (native Notis), `LOCAL_NOTIS_DATABASE_*` (databases and notes), `CUSTOM_*` (the user's remote MCP servers), `LOCAL_MCP_*` (MCP servers on the user's computer), and integration tools such as `GMAIL_*`, `NOTION_*`, and `GOOGLECALENDAR_*`.
 
 ### Main features
 

package/src/command-specs/auth.js

@@ -133,9 +133,9 @@ export const authCommandSpecs = [
   },
   {
     command_path: ['logout'],
-    summary: 'Revoke and remove the OAuth credential for one CLI profile.',
+    summary: 'Sign this computer out of one CLI profile: revoke and remove its OAuth credential.',
     when_to_use:
-      'Use this to disconnect a single account. Other profiles keep their credentials unless you pass --all-profiles.',
+      'Use this to disconnect a single account on this computer. Its sign-ins on other computers stay, and other profiles keep their credentials unless you pass --all-profiles.',
     args_schema: {
       arguments: [],
       options: [

package/src/command-specs/handover.js

@@ -2,9 +2,10 @@
  * `notis handover` -- give the branch you are on to a Notis agent.
  *
  * The coding agent already sitting in the user's terminal is the caller here.
- * It pushes the branch, then hands the task to whichever agent the user picked:
- * the hosted Notis agent, or their own Codex/Claude Code running in the Notis
- * cloud sandbox or on their Mac.
+ * It pushes the branch, then hands the task to Notis. By default (`auto`) Notis
+ * picks the agent itself; `--route notis|codex|claude` names one instead, and
+ * the server turns that into a plain sentence in the task ("Use Codex for this
+ * task."), so the user's choice wins like it does in a chat message.
  *
  * The CLI deliberately does not create the cloud workspace itself. Doing so
  * would hard-code the Conductor app's database schema and script paths into the
@@ -28,7 +29,18 @@ import { fetchToolSchema, nextIdempotencyKey, runToolCommand } from './helpers.j
 const HAND_OVER_TOOL = 'LOCAL_NOTIS_HAND_OVER';
 const SEARCH_THREADS_TOOL = 'LOCAL_NOTIS_SEARCH_CODING_AGENT_THREADS';
 
-const ROUTES = ['notis', 'auto', 'codex_cloud', 'claude_cloud', 'codex_local', 'claude_local'];
+// What --route accepts and advertises. `auto` lets Notis pick the agent.
+const ROUTES = ['auto', 'notis', 'codex', 'claude'];
+// Values from before Notis picked the agent itself. Still accepted, so scripts
+// and agents that learned them keep working, but never shown in help, examples
+// or errors. They are sent as typed; the server maps them to codex or claude.
+const LEGACY_ROUTES = new Map([
+  ['codex_cloud', 'codex'],
+  ['codex_local', 'codex'],
+  ['claude_cloud', 'claude'],
+  ['claude_local', 'claude'],
+]);
+const ROUTE_LABELS = { notis: 'Notis', codex: 'Codex', claude: 'Claude' };
 const BRANCH_MODES = ['new', 'same'];
 
 // A cloud coding agent takes minutes to start, and the hand-over POST itself
@@ -44,6 +56,17 @@ const HANDOVER_TIMEOUT_MS = 120_000;
  */
 const HANDOVER_UNAVAILABLE_CODES = new Set(['usage_error', 'forbidden']);
 
+/** A legacy route as the agent it now means; anything else unchanged. */
+function normalizeRoute(route) {
+  return LEGACY_ROUTES.get(route) || route;
+}
+
+/** Who the hand-over went to, in words, for progress lines and the summary. */
+function describeRoute(route) {
+  if (route === 'auto') return 'Notis, which picks the agent';
+  return ROUTE_LABELS[route] || route;
+}
+
 /**
  * Quote a value for the command line the receiving agent is told to run.
  *
@@ -121,8 +144,8 @@ async function handoverStartHandler(ctx) {
     throw usageError(`--branch-mode must be one of: ${BRANCH_MODES.join(', ')}`, { branchMode });
   }
 
-  const route = ctx.options.route || 'notis';
-  if (!ROUTES.includes(route)) {
+  const route = ctx.options.route || 'auto';
+  if (!ROUTES.includes(route) && !LEGACY_ROUTES.has(route)) {
     throw usageError(`--route must be one of: ${ROUTES.join(', ')}`, { route });
   }
 
@@ -223,7 +246,10 @@ async function handoverStartHandler(ctx) {
     repoSlug: ctx.options.repo || null,
   });
 
-  ctx.output.emitProgress({ phase: 'handover', message: `Handing over to ${route}` });
+  ctx.output.emitProgress({
+    phase: 'handover',
+    message: `Handing over to ${describeRoute(normalizeRoute(route))}`,
+  });
   const result = await runToolCommand({
     runtime: {
       ...ctx.runtime,
@@ -255,7 +281,9 @@ async function handoverStartHandler(ctx) {
     branch_mode: branchMode,
     head: repository.head,
     wip_commit: wipCommit,
-    agent_routing: payload.agent_routing || route,
+    // The server answers with auto, notis, codex or claude. An older server
+    // may echo a legacy value back, so map it here too.
+    agent_routing: normalizeRoute(payload.agent_routing || route),
     interaction_id: payload.interaction_id || null,
     thread_id: payload.thread_id || null,
   };
@@ -264,7 +292,7 @@ async function handoverStartHandler(ctx) {
     command: 'handover start',
     data,
     humanSummary:
-      `Handed ${data.branch} over to ${data.agent_routing} ` +
+      `Handed ${data.branch} over to ${describeRoute(data.agent_routing)} ` +
       `(${branchMode === 'same' ? 'continuing the branch' : 'new branch from it'}).`,
     hints: [
       { command: 'notis handover status', reason: 'See what the agent is doing' },
@@ -313,8 +341,8 @@ export const handoverCommandSpecs = [
     summary: 'Hand the current branch to a Notis agent and keep working.',
     when_to_use:
       'Use this when you want Notis to continue work on the branch you are on -- long refactors, ' +
-      'test fixing, or anything that should keep running after you close the laptop. Pick the agent ' +
-      'with --route.',
+      'test fixing, or anything that should keep running after you close the laptop. Notis picks ' +
+      'the agent unless you name one with --route.',
     args_schema: {
       arguments: [{ token: '<task>', description: 'What the agent should do, in plain language.' }],
       options: [
@@ -327,7 +355,7 @@ export const handoverCommandSpecs = [
         {
           flags: '--route <target>',
           description:
-            'Which agent runs it: notis (hosted, default), codex_cloud, claude_cloud, codex_local, claude_local, or auto.',
+            'Which agent runs it: auto (default, Notis picks the agent), notis, codex or claude.',
         },
         { flags: '--repo <slug>', description: 'Configured repository slug on the cloud computer, when you know it.' },
         {
@@ -338,12 +366,13 @@ export const handoverCommandSpecs = [
     },
     examples: [
       'notis handover start "fix the failing auth tests"',
-      'notis handover start "finish the migration" --branch-mode same --route codex_cloud',
-      'notis handover start "add integration tests" --route claude_cloud',
-      'notis handover start "review and clean up this branch" --route claude_local',
+      'notis handover start "finish the migration" --branch-mode same --route codex',
+      'notis handover start "add integration tests" --route claude',
+      'notis handover start "review and clean up this branch" --route notis',
     ],
     output_schema:
-      'Returns the branch, the resolved routing target, and the interaction/thread ids of the started run.',
+      'Returns the branch, the agent routing (auto when Notis picks, otherwise notis, codex or claude), ' +
+      'and the interaction/thread ids of the started run.',
     mutates: true,
     idempotent: false,
     require_auth: true,

package/src/command-specs/profile.js

@@ -1,3 +1,5 @@
+import { spawn } from 'node:child_process';
+import { CHANNEL_SWITCH_ENV } from '../runtime/channel.js';
 import { CliError, EXIT_CODES } from '../runtime/errors.js';
 import { quoteShellArgument } from '../runtime/auth-recovery.js';
 import {
@@ -114,6 +116,44 @@ async function listHandler(ctx) {
   });
 }
 
+const SKILL_SYNC_API_BASE_PATTERN = /^https:\/\/api(?:-beta)?\.notis\.ai\/?$/;
+
+// Overrides that belong to this `profile use` run. Inherited, a NOTIS_JWT would
+// sync its own account into the agent folders under the named profile.
+const RELINK_DROPPED_ENV = ['NOTIS_JWT', 'NOTIS_API_BASE', 'NOTIS_PROFILE', CHANNEL_SWITCH_ENV];
+
+// The new default's skills take over the agent folders (Claude Code, Codex,
+// Cursor) now rather than at the next automatic sync. Detached, so the switch
+// itself stays instant; a failure waits for that next sync.
+export function relinkSkillsInBackground(name, profile, {
+  env = process.env,
+  argv = process.argv,
+  execPath = process.execPath,
+  spawnImpl = spawn,
+} = {}) {
+  // Never from a test run: a detached sync would outlive it and reach the real API.
+  if (env.NODE_ENV === 'test' || env.NODE_TEST_CONTEXT || !argv[1]) return false;
+  if (!profile?.oauth_access_token && !profile?.oauth_refresh_token) return false;
+  if (!SKILL_SYNC_API_BASE_PATTERN.test(String(profile.api_base || ''))) return false;
+  // Like the automatic sync, the relink runs as the named profile alone: its
+  // credential, its endpoint and the CLI build for its channel.
+  const childEnv = { ...env };
+  for (const key of RELINK_DROPPED_ENV) delete childEnv[key];
+  try {
+    const child = spawnImpl(
+      execPath,
+      [argv[1], 'skills', 'sync', '--json', '--profile', name],
+      { detached: true, stdio: 'ignore', env: childEnv },
+    );
+    child.on('error', () => {});
+    child.unref();
+    return true;
+  } catch {
+    // The next automatic sync relinks.
+    return false;
+  }
+}
+
 async function useHandler(ctx) {
   const requested = ctx.args.name;
   const config = loadConfig();
@@ -132,6 +172,7 @@ async function useHandler(ctx) {
   const worktreeOverride = Boolean(worktreeRuntime);
   const worktreeBlocked = Boolean(worktreeUnavailable);
   const authenticated = profileHasCredential(profile);
+  if (authenticated) relinkSkillsInBackground(requested, profile);
 
   return ctx.output.emitSuccess({
     command: ctx.spec.command_path.join(' '),
@@ -298,7 +339,7 @@ export const profileCommandSpecs = [
     command_path: ['profile', 'use'],
     summary: 'Switch the default profile without signing any profile out.',
     when_to_use:
-      'Use this to change which account and API subsequent commands target. Every other profile keeps its credential.',
+      'Use this to change which account and API subsequent commands target. Every other profile keeps its credential. Its skills replace the previous default\'s in the agent folders (Claude Code, Codex, Cursor) straight away.',
     args_schema: {
       arguments: [{ token: '<name>', key: 'name', description: 'Profile to make active.' }],
       options: [],

package/src/command-specs/skills.js

@@ -1,4 +1,4 @@
-import { getJwtSubject } from '../runtime/profiles.js';
+import { getCurrentProfileName, getJwtSubject, loadConfig } from '../runtime/profiles.js';
 import { reconcileAllSkills } from '../runtime/sync-skills.js';
 import { ensureFreshOAuthCredential } from '../runtime/oauth.js';
 import { installSkillSyncService } from '../runtime/skill-sync-service.js';
@@ -82,6 +82,15 @@ async function loadSkillSyncEngine() {
   return import('../../dist/skill-sync/index.js');
 }
 
+function cliDefaultOwnsAgentFolders(runtime) {
+  if (runtime.profileSource !== 'explicit' || !runtime.profileName) return true;
+  try {
+    return runtime.profileName === getCurrentProfileName(loadConfig());
+  } catch {
+    return true;
+  }
+}
+
 export async function syncSkillsHandler(ctx, {
   refresh = ensureFreshOAuthCredential, loadEngine = loadSkillSyncEngine,
   reconcile = reconcileAllSkills, install = installSkillSyncService,
@@ -95,6 +104,9 @@ export async function syncSkillsHandler(ctx, {
     jwt: ctx.runtime.jwt,
     userId: settings.user_id || userId,
     honorSyncEnabled: Boolean(ctx.options.electronRepeat),
+    // Only the CLI default's skills go into the agent folders; another profile
+    // syncs its own folder.
+    linkAgentFolders: cliDefaultOwnsAgentFolders(ctx.runtime),
     runAccountSync: (serverUrl, jwt, dependencies, options) => runSkillSync(
       serverUrl, jwt, { ...dependencies, fetchSyncSettings: async () => settings }, options,
     ),

package/src/runtime/computer-identity.d.ts

@@ -0,0 +1,30 @@
+export interface ComputerIdentity {
+  /** Stable UUID v4 for this computer, shared by every account on it. */
+  computerId: string;
+  /** The name the user chose, or null to use the computer's own name. */
+  name: string | null;
+  /** The computer's own name (macOS Computer Name, else the host name). */
+  defaultName: string;
+  /** `name ?? defaultName`, what the server and the user see. */
+  displayName: string;
+}
+
+export interface ComputerIdentityOptions {
+  /** The CLI config file computer.json sits next to. Defaults to NOTIS_CLI_CONFIG_FILE or ~/.notis/config.json. */
+  configFile?: string;
+  platform?: NodeJS.Platform;
+  hostname?: () => string;
+  readMacComputerName?: () => string | null;
+}
+
+export const COMPUTER_IDENTITY_VERSION: number;
+export const COMPUTER_NAME_MAX_LENGTH: number;
+
+export function computerIdentityFile(configFile?: string): string;
+export function normalizeComputerName(value: unknown): string | null;
+export function defaultComputerName(options?: ComputerIdentityOptions): string;
+export function readComputerIdentity(options?: ComputerIdentityOptions): ComputerIdentity;
+export function setComputerName(
+  name: string | null,
+  options?: ComputerIdentityOptions,
+): ComputerIdentity;

package/src/runtime/computer-identity.js

@@ -0,0 +1,151 @@
+import { randomUUID } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { hostname as osHostname } from 'node:os';
+import { dirname, join } from 'node:path';
+import { resolveCliConfigFile, withConfigFileWriteLock } from './config-lock.js';
+
+// This computer's identity, shared by the CLI and Desktop: one stable id per
+// computer (the server keeps one CLI sign-in and one local shell connection per
+// computer) and the name the user sees for it. It lives next to the CLI config
+// file, so NOTIS_CLI_CONFIG_FILE moves it too, and is written under the same
+// lock as the config.
+export const COMPUTER_IDENTITY_VERSION = 1;
+export const COMPUTER_NAME_MAX_LENGTH = 64;
+const COMPUTER_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const FALLBACK_COMPUTER_NAME = 'Computer';
+
+export function computerIdentityFile(configFile = resolveCliConfigFile()) {
+  return join(dirname(configFile), 'computer.json');
+}
+
+/**
+ * Trim, collapse whitespace and cap at 64 characters. Returns null for a name
+ * that is empty after cleanup, which means "use the computer's own name".
+ */
+export function normalizeComputerName(value) {
+  if (typeof value !== 'string') return null;
+  const collapsed = value.replace(/\s+/gu, ' ').trim();
+  if (!collapsed) return null;
+  // Count code points so a cut never splits a character in two.
+  const characters = Array.from(collapsed);
+  if (characters.length <= COMPUTER_NAME_MAX_LENGTH) return collapsed;
+  return characters.slice(0, COMPUTER_NAME_MAX_LENGTH).join('').trim();
+}
+
+function readMacComputerName() {
+  try {
+    return execFileSync('/usr/sbin/scutil', ['--get', 'ComputerName'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 2_000,
+    });
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The computer's own name: the macOS Computer Name, else the host name without
+ * a trailing `.local`.
+ */
+export function defaultComputerName(options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (platform === 'darwin') {
+    const macName = normalizeComputerName((options.readMacComputerName ?? readMacComputerName)());
+    if (macName) return macName;
+  }
+  let host = '';
+  try {
+    host = String((options.hostname ?? osHostname)() || '');
+  } catch {
+    host = '';
+  }
+  return normalizeComputerName(host.replace(/\.local\.?$/iu, '')) || FALLBACK_COMPUTER_NAME;
+}
+
+function parseIdentityFile(file) {
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+  return raw;
+}
+
+function validStored(raw) {
+  if (!raw || raw.version !== COMPUTER_IDENTITY_VERSION) return null;
+  if (typeof raw.computer_id !== 'string' || !COMPUTER_ID_PATTERN.test(raw.computer_id)) return null;
+  return {
+    computerId: raw.computer_id.toLowerCase(),
+    name: normalizeComputerName(raw.name),
+  };
+}
+
+function writeIdentityFile(file, stored) {
+  mkdirSync(dirname(file), { recursive: true });
+  const contents = {
+    version: COMPUTER_IDENTITY_VERSION,
+    computer_id: stored.computerId,
+    ...(stored.name ? { name: stored.name } : {}),
+  };
+  const temporaryFile = `${file}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(temporaryFile, `${JSON.stringify(contents, null, 2)}\n`, { mode: 0o600 });
+  renameSync(temporaryFile, file);
+}
+
+function withIdentity(stored, options) {
+  const defaultName = defaultComputerName(options);
+  return {
+    computerId: stored.computerId,
+    name: stored.name,
+    defaultName,
+    displayName: stored.name ?? defaultName,
+  };
+}
+
+// Under the config lock: re-read so two first reads agree on one id, then
+// create (or repair) the file only when it holds no valid identity.
+function readOrCreateLocked(configFile, file) {
+  const raw = parseIdentityFile(file);
+  const existing = validStored(raw);
+  if (existing) return existing;
+  const created = {
+    computerId: randomUUID(),
+    // A file with a broken id keeps the name the user chose.
+    name: normalizeComputerName(raw?.name),
+  };
+  writeIdentityFile(file, created);
+  return created;
+}
+
+/**
+ * Read this computer's identity, creating `computer.json` on first read.
+ */
+export function readComputerIdentity(options = {}) {
+  const configFile = options.configFile ?? resolveCliConfigFile();
+  const file = computerIdentityFile(configFile);
+  const stored = validStored(parseIdentityFile(file))
+    ?? withConfigFileWriteLock(configFile, () => readOrCreateLocked(configFile, file));
+  return withIdentity(stored, options);
+}
+
+/**
+ * Rename this computer for every account on it. An empty name goes back to the
+ * computer's own name.
+ */
+export function setComputerName(name, options = {}) {
+  const configFile = options.configFile ?? resolveCliConfigFile();
+  const file = computerIdentityFile(configFile);
+  const stored = withConfigFileWriteLock(configFile, () => {
+    const current = readOrCreateLocked(configFile, file);
+    const next = { computerId: current.computerId, name: normalizeComputerName(name) };
+    if (next.name !== current.name) {
+      writeIdentityFile(file, next);
+    }
+    return next;
+  });
+  return withIdentity(stored, options);
+}

package/src/runtime/config-lock.js

@@ -0,0 +1,135 @@
+import { randomUUID } from 'node:crypto';
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+
+// Cross-process write lock over ~/.notis/config.json. Independent `notis`
+// processes (a `login` in one terminal and a `tools exec` in another) and
+// Desktop all rewrite the files in this directory, so the lock directory name
+// and these three timings are the whole coordination protocol. Desktop keeps a
+// TypeScript copy in electron/src/notis-config-file.ts. Guarded by the
+// concurrency test in packages/cli/test/runtime-auth.test.js.
+const CONFIG_WRITE_LOCK_TIMEOUT_MS = 5_000;
+const CONFIG_WRITE_LOCK_STALE_MS = 2_000;
+const CONFIG_WRITE_LOCK_POLL_MS = 10;
+
+/**
+ * The shared CLI config file. NOTIS_CLI_CONFIG_FILE moves it (and every file
+ * kept next to it, such as computer.json) for tests and isolated runtimes.
+ */
+export function resolveCliConfigFile() {
+  const envConfigFile = process.env.NOTIS_CLI_CONFIG_FILE;
+  if (envConfigFile) {
+    return resolve(envConfigFile);
+  }
+  return join(homedir(), '.notis', 'config.json');
+}
+
+// The lock records who holds it and when they took it. Reclaiming a stale lock
+// by mtime alone is not safe: the reclaimer cannot tell an abandoned lock from
+// one it is about to steal from a live writer, and the victim's own release
+// would then delete the thief's lock and admit a third writer. Both sides are
+// on the same host, so the stored timestamp and Date.now() share a clock.
+function readLockOwner(lockDirectory) {
+  try {
+    return JSON.parse(readFileSync(join(lockDirectory, 'owner'), 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function lockDirectoryMtime(lockDirectory) {
+  try {
+    return statSync(lockDirectory).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+
+function publishConfigWriteLock(lockDirectory, ownerId) {
+  const candidateDirectory = `${lockDirectory}.candidate-${ownerId}`;
+  try {
+    mkdirSync(candidateDirectory);
+    writeFileSync(
+      join(candidateDirectory, 'owner'),
+      JSON.stringify({ id: ownerId, at: Date.now() }),
+      { mode: 0o600 },
+    );
+    try {
+      renameSync(candidateDirectory, lockDirectory);
+      return true;
+    } catch (error) {
+      if (!existsSync(lockDirectory)) throw error;
+      return false;
+    }
+  } finally {
+    rmSync(candidateDirectory, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Run `callback(configFile)` while holding `<configFile>.write-lock`.
+ */
+export function withConfigFileWriteLock(configFile, callback) {
+  const lockDirectory = `${configFile}.write-lock`;
+  const ownerId = `${process.pid}.${randomUUID()}`;
+  const deadline = Date.now() + CONFIG_WRITE_LOCK_TIMEOUT_MS;
+  mkdirSync(dirname(configFile), { recursive: true });
+  for (;;) {
+    if (!existsSync(lockDirectory) && publishConfigWriteLock(lockDirectory, ownerId)) {
+      break;
+    }
+
+    const owner = readLockOwner(lockDirectory);
+    const observedMtime = lockDirectoryMtime(lockDirectory);
+    const ownerIsStale =
+      owner?.id && Date.now() - Number(owner.at) > CONFIG_WRITE_LOCK_STALE_MS;
+    const ownerlessIsStale =
+      !owner
+      && observedMtime !== null
+      && Date.now() - observedMtime > CONFIG_WRITE_LOCK_STALE_MS;
+    if (ownerIsStale || ownerlessIsStale) {
+      try {
+        const currentOwner = readLockOwner(lockDirectory);
+        const ownerUnchanged = owner?.id
+          ? currentOwner?.id === owner.id
+          : !currentOwner && lockDirectoryMtime(lockDirectory) === observedMtime;
+        if (ownerUnchanged) {
+          rmSync(lockDirectory, { recursive: true, force: true });
+          continue;
+        }
+      } catch {
+        // Losing the reclaim race is normal; fall through and keep waiting.
+      }
+    }
+    if (Date.now() >= deadline) {
+      throw new Error(`Timed out waiting to update ${configFile}`);
+    }
+    Atomics.wait(
+      new Int32Array(new SharedArrayBuffer(4)),
+      0,
+      0,
+      CONFIG_WRITE_LOCK_POLL_MS,
+    );
+  }
+  try {
+    return callback(configFile);
+  } finally {
+    try {
+      // Never release a lock that was reclaimed from us while we worked.
+      if (readLockOwner(lockDirectory)?.id === ownerId) {
+        rmSync(lockDirectory, { recursive: true, force: true });
+      }
+    } catch {
+      // The lock may already have been removed after an interrupted write.
+    }
+  }
+}

package/src/runtime/oauth.js

@@ -21,6 +21,7 @@ import { execFileSync, spawn } from 'node:child_process';
 import { createInterface } from 'node:readline/promises';
 
 import { CliError, EXIT_CODES, usageError } from './errors.js';
+import { readComputerIdentity } from './computer-identity.js';
 import { getAuthRecovery, quoteShellArgument } from './auth-recovery.js';
 import {
   channelFromProfile,
@@ -674,7 +675,19 @@ function storedOAuthMetadata(runtime, profile) {
   };
 }
 
-function buildAuthorizeUrl(metadata, {
+// This computer's id and name, so the server keeps one CLI sign-in per
+// computer and lists it as "Notis CLI on <computer>". Best effort: a sign-in
+// without them still works and maps to the shared legacy grant.
+function cliDeviceParams() {
+  try {
+    const identity = readComputerIdentity({ configFile: resolveConfigFile() });
+    return { device_id: identity.computerId, device_name: identity.displayName };
+  } catch {
+    return {};
+  }
+}
+
+export function buildAuthorizeUrl(metadata, {
   redirectUri,
   challenge,
   state,
@@ -689,6 +702,9 @@ function buildAuthorizeUrl(metadata, {
   url.searchParams.set('code_challenge', challenge);
   url.searchParams.set('code_challenge_method', 'S256');
   url.searchParams.set('state', state);
+  for (const [key, value] of Object.entries(cliDeviceParams())) {
+    url.searchParams.set(key, value);
+  }
   return url.toString();
 }
 
@@ -2473,6 +2489,7 @@ export async function refreshOAuthCredential(runtime, fetchImpl = fetch) {
           refresh_token: profile.oauth_refresh_token,
           client_id: profile.oauth_client_id,
           resource: metadata.resource,
+          ...cliDeviceParams(),
         }),
       },
       fetchImpl,