@dmsdc-ai/aterm 0.1.1 → 0.1.2

package/bin/aterm.js

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
+import { resolveAigentryConfig } from '../lib/aigentry.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -10,6 +11,7 @@ const packageRoot = path.resolve(__dirname, '..');
 const appRoot = path.join(packageRoot, 'dist', 'aterm.app');
 const executable = path.join(appRoot, 'Contents', 'MacOS', 'aterm');
 const frameworksDir = path.join(appRoot, 'Contents', 'Frameworks');
+const resolvedConfig = resolveAigentryConfig({ cwd: process.cwd() });
 
 if (!fs.existsSync(executable)) {
   console.error('[aterm] native app bundle is not installed');
@@ -17,10 +19,20 @@ if (!fs.existsSync(executable)) {
   process.exit(1);
 }
 
+for (const warning of resolvedConfig.warnings) {
+  console.warn(warning);
+}
+
 const env = { ...process.env };
 env.DYLD_LIBRARY_PATH = [frameworksDir, env.DYLD_LIBRARY_PATH]
   .filter(Boolean)
   .join(':');
+env.AIGENTRY_CONFIG_JSON = JSON.stringify(resolvedConfig.config);
+env.AIGENTRY_CONFIG_LAYERS = JSON.stringify(resolvedConfig.layers);
+env.AIGENTRY_SYSTEM_ROOT = resolvedConfig.systemRoot;
+env.AIGENTRY_USER_ROOT = resolvedConfig.userRoot;
+env.AIGENTRY_PROJECT_ROOT = resolvedConfig.projectRoot;
+env.AIGENTRY_PROJECT_AIGENTRY_ROOT = resolvedConfig.projectAigentryRoot;
 
 const child = spawn(executable, process.argv.slice(2), {
   stdio: 'inherit',

package/lib/aigentry.js

@@ -0,0 +1,425 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+const SYSTEM_ROOT = process.env.AIGENTRY_SYSTEM_ROOT || '/etc/aigentry';
+
+const TASK_QUEUE_DEFAULT = {
+  main_topics: [],
+  tasks: [],
+  completed: [],
+};
+
+const LESSONS_DEFAULT = {
+  _meta: { version: 1 },
+  aterm: {
+    invariants: [],
+    failed: [],
+  },
+};
+
+const PROJECT_AGENTS_TEMPLATE = `# Project AI Instructions
+
+- Add project-specific aigentry instructions here.
+- This file is project-scoped and overrides user/system defaults when present.
+`;
+
+function cloneJsonValue(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function mergeJson(base, override) {
+  if (!isPlainObject(base)) {
+    return cloneJsonValue(override);
+  }
+
+  const merged = { ...cloneJsonValue(base) };
+  for (const [key, value] of Object.entries(override)) {
+    if (isPlainObject(value) && isPlainObject(merged[key])) {
+      merged[key] = mergeJson(merged[key], value);
+      continue;
+    }
+    merged[key] = cloneJsonValue(value);
+  }
+  return merged;
+}
+
+function ensureDirectory(directoryPath) {
+  const existed = fs.existsSync(directoryPath);
+  fs.mkdirSync(directoryPath, { recursive: true });
+  return !existed;
+}
+
+function ensureJsonFile(filePath, defaultValue) {
+  ensureDirectory(path.dirname(filePath));
+  if (fs.existsSync(filePath)) {
+    return false;
+  }
+
+  fs.writeFileSync(filePath, `${JSON.stringify(defaultValue, null, 2)}\n`);
+  return true;
+}
+
+function ensureTextFile(filePath, contents) {
+  ensureDirectory(path.dirname(filePath));
+  if (fs.existsSync(filePath)) {
+    return false;
+  }
+
+  fs.writeFileSync(filePath, contents);
+  return true;
+}
+
+function readJsonFile(filePath, warnings) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (error) {
+    warnings.push(`[aterm] invalid JSON config skipped: ${filePath} (${error.message})`);
+    return null;
+  }
+}
+
+function resolveUserHomeFromSudoUser() {
+  const sudoUser = process.env.SUDO_USER;
+  if (!sudoUser || sudoUser === 'root' || !/^[A-Za-z0-9_.-]+$/.test(sudoUser)) {
+    return null;
+  }
+
+  const result = spawnSync('/bin/sh', ['-lc', `printf %s ~${sudoUser}`], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore'],
+  });
+  if (result.status !== 0) {
+    return null;
+  }
+
+  const resolved = result.stdout.trim();
+  if (!resolved || resolved === `~${sudoUser}`) {
+    return null;
+  }
+
+  return resolved;
+}
+
+function commandAvailable(command) {
+  const result = spawnSync('/bin/sh', ['-lc', `command -v ${command} >/dev/null 2>&1`], {
+    stdio: 'ignore',
+  });
+  return result.status === 0;
+}
+
+function findGitRoot(startDir) {
+  const resolvedStartDir = path.resolve(startDir);
+  const result = spawnSync('git', ['rev-parse', '--show-toplevel'], {
+    cwd: resolvedStartDir,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore'],
+  });
+
+  if (result.status !== 0) {
+    return null;
+  }
+
+  const gitRoot = result.stdout.trim();
+  return gitRoot ? path.resolve(gitRoot) : null;
+}
+
+function buildLevelPaths(aigentryRoot, options = {}) {
+  const paths = {
+    root: aigentryRoot,
+    config: path.join(aigentryRoot, 'config'),
+    data: path.join(aigentryRoot, 'data'),
+    brain_local: path.join(aigentryRoot, 'brain', 'local'),
+    brain_profiles: path.join(aigentryRoot, 'brain', 'profiles'),
+    inbox: path.join(aigentryRoot, 'inbox'),
+    telepty_shared: path.join(aigentryRoot, 'telepty', 'shared'),
+    cache_search: path.join(aigentryRoot, 'cache', 'search'),
+    logs: path.join(aigentryRoot, 'logs'),
+  };
+
+  if (options.legacyTeleptyShared) {
+    paths.legacy_telepty_shared = options.legacyTeleptyShared;
+  }
+
+  return paths;
+}
+
+function buildDefaultConfig(options) {
+  const config = {
+    version: options.version,
+    level: options.level,
+    installed_at: new Date().toISOString(),
+    platform: `${os.platform()}-${os.arch()}`,
+    paths: buildLevelPaths(options.aigentryRoot, {
+      legacyTeleptyShared: options.legacyTeleptyShared,
+    }),
+    shell: {
+      default: options.defaultShell ?? 'zsh',
+    },
+    workspace: {
+      default: options.defaultWorkspace ?? 'home',
+    },
+    orchestrator: {
+      enabled: false,
+      path: path.join(os.homedir(), 'projects', 'aigentry-orchestrator'),
+    },
+    tailscale: {
+      connect_on_launch: false,
+    },
+  };
+
+  if (options.projectRoot) {
+    config.project_root = options.projectRoot;
+  }
+
+  return config;
+}
+
+function ensureStructuredRoot(aigentryRoot, options) {
+  const reportProgress = options.onProgress ?? (() => {});
+  const directories = [
+    path.join(aigentryRoot, 'config'),
+    path.join(aigentryRoot, 'data'),
+    path.join(aigentryRoot, 'brain', 'local'),
+    path.join(aigentryRoot, 'brain', 'profiles'),
+    path.join(aigentryRoot, 'inbox'),
+    path.join(aigentryRoot, 'telepty', 'shared'),
+    path.join(aigentryRoot, 'cache', 'search'),
+    path.join(aigentryRoot, 'logs'),
+  ];
+
+  for (const directoryPath of directories) {
+    ensureDirectory(directoryPath);
+    reportProgress({ type: 'dir', path: directoryPath });
+  }
+
+  if (options.legacyTeleptyShared) {
+    ensureDirectory(options.legacyTeleptyShared);
+    reportProgress({ type: 'dir', path: options.legacyTeleptyShared });
+  }
+
+  const configPath = path.join(aigentryRoot, 'config', 'aterm.json');
+  const taskQueuePath = path.join(aigentryRoot, 'data', 'task-queue.json');
+  const lessonsPath = path.join(aigentryRoot, 'data', 'lessons.json');
+  ensureJsonFile(configPath, buildDefaultConfig(options));
+  reportProgress({ type: 'file', path: configPath });
+  ensureJsonFile(taskQueuePath, TASK_QUEUE_DEFAULT);
+  reportProgress({ type: 'file', path: taskQueuePath });
+  ensureJsonFile(lessonsPath, LESSONS_DEFAULT);
+  reportProgress({ type: 'file', path: lessonsPath });
+
+  if (options.createAgentsFile) {
+    const agentsPath = path.join(aigentryRoot, 'AGENTS.md');
+    ensureTextFile(agentsPath, PROJECT_AGENTS_TEMPLATE);
+    reportProgress({ type: 'file', path: agentsPath });
+  }
+
+  if (options.configPatch) {
+    updateConfigFile(configPath, options.configPatch);
+    reportProgress({ type: 'file', path: configPath, patched: true });
+  }
+
+  return {
+    aigentryRoot,
+    configPath,
+  };
+}
+
+export function getSystemAigentryRoot() {
+  return SYSTEM_ROOT;
+}
+
+export function getUserAigentryRoot(homeDir = os.homedir()) {
+  return path.join(homeDir, '.aigentry');
+}
+
+export function getLegacyTeleptyShared(homeDir = os.homedir()) {
+  return path.join(homeDir, '.telepty', 'shared');
+}
+
+export function resolveInstallHomeDir() {
+  return resolveUserHomeFromSudoUser() ?? os.homedir();
+}
+
+export function resolveProjectRoot(startDir = process.cwd()) {
+  return findGitRoot(startDir) ?? path.resolve(startDir);
+}
+
+export function isGlobalInstall(env = process.env) {
+  return env.npm_config_global === 'true';
+}
+
+export function detectAiCliStatus(homeDir = os.homedir()) {
+  return {
+    claude: commandAvailable('claude') && fs.existsSync(path.join(homeDir, '.claude')),
+    codex: commandAvailable('codex') && fs.existsSync(path.join(homeDir, '.codex')),
+    gemini: commandAvailable('gemini') && fs.existsSync(path.join(homeDir, '.gemini')),
+  };
+}
+
+export function updateConfigFile(configPath, patch) {
+  const existing = fs.existsSync(configPath)
+    ? JSON.parse(fs.readFileSync(configPath, 'utf8'))
+    : {};
+  const merged = mergeJson(existing, patch);
+  fs.writeFileSync(configPath, `${JSON.stringify(merged, null, 2)}\n`);
+  return merged;
+}
+
+export function ensureSystemLayout(options) {
+  const systemRoot = getSystemAigentryRoot();
+  const configPath = path.join(systemRoot, 'config', 'aterm.json');
+
+  try {
+    ensureDirectory(path.dirname(configPath));
+    ensureJsonFile(
+      configPath,
+      buildDefaultConfig({
+        level: 'system',
+        version: options.version,
+        aigentryRoot: systemRoot,
+      }),
+    );
+    return {
+      skipped: false,
+      aigentryRoot: systemRoot,
+      configPath,
+    };
+  } catch (error) {
+    if (error.code === 'EACCES' || error.code === 'EPERM') {
+      return {
+        skipped: true,
+        reason: `${systemRoot} is not writable`,
+      };
+    }
+    throw error;
+  }
+}
+
+export function ensureUserLayout(options) {
+  const homeDir = options.homeDir ?? resolveInstallHomeDir();
+  const userRoot = getUserAigentryRoot(homeDir);
+  return ensureStructuredRoot(userRoot, {
+    level: 'user',
+    version: options.version,
+    aigentryRoot: userRoot,
+    legacyTeleptyShared: getLegacyTeleptyShared(homeDir),
+    defaultShell: options.defaultShell,
+    defaultWorkspace: options.defaultWorkspace,
+    configPatch: options.configPatch,
+    onProgress: options.onProgress,
+  });
+}
+
+export function addGitignoreSuggestion(projectRoot) {
+  const gitRoot = findGitRoot(projectRoot);
+  if (!gitRoot) {
+    return {
+      updated: false,
+      gitignorePath: null,
+    };
+  }
+
+  const gitignorePath = path.join(gitRoot, '.gitignore');
+  const entryPattern = /^\s*(?:\/?\.aigentry\/)\s*$/m;
+  const currentContents = fs.existsSync(gitignorePath)
+    ? fs.readFileSync(gitignorePath, 'utf8')
+    : '';
+
+  if (entryPattern.test(currentContents)) {
+    return {
+      updated: false,
+      gitignorePath,
+    };
+  }
+
+  const prefix = currentContents && !currentContents.endsWith('\n') ? '\n' : '';
+  fs.writeFileSync(
+    gitignorePath,
+    `${currentContents}${prefix}# aterm project config\n.aigentry/\n`,
+  );
+
+  return {
+    updated: true,
+    gitignorePath,
+  };
+}
+
+export function ensureProjectLayout(options) {
+  const projectRoot = resolveProjectRoot(options.startDir);
+  const aigentryRoot = path.join(projectRoot, '.aigentry');
+  const layout = ensureStructuredRoot(aigentryRoot, {
+    level: 'project',
+    version: options.version,
+    aigentryRoot,
+    projectRoot,
+    createAgentsFile: true,
+    defaultShell: options.defaultShell,
+    defaultWorkspace: options.defaultWorkspace,
+    configPatch: options.configPatch,
+    onProgress: options.onProgress,
+  });
+  const gitignore = addGitignoreSuggestion(projectRoot);
+
+  return {
+    ...layout,
+    projectRoot,
+    gitignoreUpdated: gitignore.updated,
+    gitignorePath: gitignore.gitignorePath,
+  };
+}
+
+export function resolveAigentryConfig(options = {}) {
+  const warnings = [];
+  const currentWorkingDirectory = options.cwd ?? process.cwd();
+  const userRoot = getUserAigentryRoot();
+  const projectRoot = resolveProjectRoot(currentWorkingDirectory);
+  const layerCandidates = [
+    {
+      level: 'system',
+      path: path.join(getSystemAigentryRoot(), 'config', 'aterm.json'),
+    },
+    {
+      level: 'user',
+      path: path.join(userRoot, 'config', 'aterm.json'),
+    },
+    {
+      level: 'project',
+      path: path.join(projectRoot, '.aigentry', 'config', 'aterm.json'),
+    },
+  ];
+
+  let mergedConfig = {};
+  const layers = [];
+
+  for (const layer of layerCandidates) {
+    const data = readJsonFile(layer.path, warnings);
+    if (!data) {
+      continue;
+    }
+    mergedConfig = mergeJson(mergedConfig, data);
+    layers.push({
+      level: layer.level,
+      path: layer.path,
+    });
+  }
+
+  return {
+    config: mergedConfig,
+    layers,
+    warnings,
+    systemRoot: getSystemAigentryRoot(),
+    userRoot,
+    projectRoot,
+    projectAigentryRoot: path.join(projectRoot, '.aigentry'),
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dmsdc-ai/aterm",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Native aterm launcher package",
   "type": "module",
   "main": "./bin/aterm.js",
@@ -8,15 +8,23 @@
     "aterm": "bin/aterm.js"
   },
   "scripts": {
-    "postinstall": "node install.js"
+    "postinstall": "node scripts/postinstall.js"
   },
   "files": [
     "bin",
-    "install.js",
+    "lib",
+    "scripts",
     "package.json"
   ],
   "optionalDependencies": {
-    "@dmsdc-ai/aterm-darwin-arm64": "0.1.1"
+    "@dmsdc-ai/aterm-darwin-arm64": "0.1.2"
+  },
+  "dependencies": {
+    "@dmsdc-ai/aigentry-brain": "latest",
+    "@dmsdc-ai/aigentry-deliberation": "latest",
+    "@dmsdc-ai/aigentry-telepty": "latest",
+    "blessed": "^0.1.81",
+    "prompts": "^2.4.2"
   },
   "license": "UNLICENSED",
   "publishConfig": {

package/scripts/postinstall.js

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+import {
+  detectAiCliStatus,
+  ensureProjectLayout,
+  ensureSystemLayout,
+  ensureUserLayout,
+  isGlobalInstall,
+  resolveInstallHomeDir,
+  resolveProjectRoot,
+} from '../lib/aigentry.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageRoot = path.resolve(__dirname, '..');
+const require = createRequire(import.meta.url);
+const packageJson = JSON.parse(
+  fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'),
+);
+
+const PLATFORM_PACKAGES = {
+  darwin: {
+    arm64: '@dmsdc-ai/aterm-darwin-arm64',
+  },
+};
+
+function resolvePlatformPackage() {
+  return PLATFORM_PACKAGES[process.platform]?.[process.arch] ?? null;
+}
+
+async function collectInstallerPlan() {
+  const mode = isGlobalInstall() ? 'global' : 'local';
+  const installRoot = process.env.INIT_CWD ? path.resolve(process.env.INIT_CWD) : process.cwd();
+  const projectRoot = mode === 'local' ? resolveProjectRoot(installRoot) : null;
+
+  const defaultPlan = {
+    installLevels: mode === 'global' ? ['system', 'user'] : ['project'],
+    configPatch: {
+      shell: { default: 'zsh' },
+      workspace: {
+        default: mode === 'local' ? 'project' : 'home',
+        path: mode === 'local' ? projectRoot : resolveInstallHomeDir(),
+      },
+      orchestrator: {
+        enabled: false,
+        path: path.join(resolveInstallHomeDir(), 'projects', 'aigentry-orchestrator'),
+      },
+      tailscale: {
+        connect_on_launch: false,
+      },
+      ai: {
+        detected_clis: detectAiCliStatus(resolveInstallHomeDir()),
+      },
+    },
+    mode,
+    projectRoot,
+  };
+
+  let tuiModule;
+  try {
+    tuiModule = await import('./tui-installer.js');
+  } catch (error) {
+    console.warn(`[aterm] installer TUI unavailable, falling back to defaults (${error.message})`);
+    return defaultPlan;
+  }
+
+  if (!tuiModule.shouldRunInstallerTui()) {
+    return defaultPlan;
+  }
+
+  const context = tuiModule.buildInstallerContext(mode, projectRoot);
+  const plan = await tuiModule.runInstallerTui(context);
+  return {
+    ...defaultPlan,
+    ...plan,
+  };
+}
+
+function applyInstallPlan(plan, progress) {
+  const onProgress = (event) => {
+    if (!progress) {
+      return;
+    }
+    if (event.type === 'dir') {
+      progress(`{green-fg}dir{/} ${event.path}`);
+      return;
+    }
+    progress(`{cyan-fg}file{/} ${event.path}`);
+  };
+
+  if (plan.installLevels.includes('system')) {
+    progress?.('{bold}Preparing system level{/bold}');
+    const systemLayout = ensureSystemLayout({
+      version: packageJson.version,
+    });
+    if (systemLayout.skipped) {
+      progress?.(`{yellow-fg}skip{/} system: ${systemLayout.reason}`);
+    } else {
+      progress?.(`{green-fg}ok{/} ${systemLayout.configPath}`);
+    }
+  }
+
+  if (plan.installLevels.includes('user')) {
+    progress?.('{bold}Preparing user level{/bold}');
+    const userLayout = ensureUserLayout({
+      version: packageJson.version,
+      configPatch: plan.configPatch,
+      defaultShell: plan.configPatch.shell?.default,
+      defaultWorkspace: plan.configPatch.workspace?.default,
+      onProgress,
+    });
+    progress?.(`{green-fg}ok{/} ${userLayout.configPath}`);
+  }
+
+  if (plan.installLevels.includes('project')) {
+    progress?.('{bold}Preparing project level{/bold}');
+    const projectLayout = ensureProjectLayout({
+      version: packageJson.version,
+      startDir: plan.projectRoot,
+      configPatch: plan.configPatch,
+      defaultShell: plan.configPatch.shell?.default,
+      defaultWorkspace: plan.configPatch.workspace?.default,
+      onProgress,
+    });
+    progress?.(`{green-fg}ok{/} ${projectLayout.configPath}`);
+    if (projectLayout.gitignoreUpdated && projectLayout.gitignorePath) {
+      progress?.(`{green-fg}ok{/} added .aigentry/ to ${projectLayout.gitignorePath}`);
+    }
+  }
+}
+
+function installNativeBundle() {
+  const platformPackage = resolvePlatformPackage();
+  if (!platformPackage) {
+    console.warn(
+      `[aterm] no native package for ${process.platform} ${process.arch}; install skipped`,
+    );
+    process.exit(0);
+  }
+
+  let platformPackageJsonPath;
+  try {
+    platformPackageJsonPath = require.resolve(`${platformPackage}/package.json`);
+  } catch {
+    console.warn(`[aterm] optional native package not installed: ${platformPackage}`);
+    console.warn('[aterm] reinstall after the platform package is available');
+    process.exit(0);
+  }
+
+  const platformRoot = path.dirname(platformPackageJsonPath);
+  const sourceApp = path.join(platformRoot, 'dist', 'aterm.app');
+  const targetApp = path.join(packageRoot, 'dist', 'aterm.app');
+
+  if (!fs.existsSync(sourceApp)) {
+    console.error(`[aterm] native app bundle missing from ${platformPackage}: ${sourceApp}`);
+    process.exit(1);
+  }
+
+  fs.rmSync(path.dirname(targetApp), { recursive: true, force: true });
+  fs.mkdirSync(path.dirname(targetApp), { recursive: true });
+  fs.cpSync(sourceApp, targetApp, { recursive: true });
+
+  console.log(`[aterm] installed native bundle from ${platformPackage}`);
+}
+
+async function main() {
+  const plan = await collectInstallerPlan();
+
+  let tuiModule = null;
+  try {
+    tuiModule = await import('./tui-installer.js');
+  } catch {
+    tuiModule = null;
+  }
+
+  if (tuiModule?.shouldRunInstallerTui()) {
+    await tuiModule.showProgressScreen(async (progress) => {
+      applyInstallPlan(plan, progress);
+      progress('{bold}Staging native bundle{/bold}');
+      installNativeBundle();
+      progress('{green-fg}ok{/} native bundle ready');
+    });
+
+    await tuiModule.showDoneScreen([
+      'aterm setup is complete.',
+      '',
+      `Mode: ${plan.mode}`,
+      `Levels: ${plan.installLevels.join(', ')}`,
+      `Shell: ${plan.configPatch.shell?.default ?? 'zsh'}`,
+      `Workspace: ${plan.configPatch.workspace?.default ?? 'home'}`,
+      `Tailscale connect: ${plan.configPatch.tailscale?.connect_on_launch ? 'yes' : 'no'}`,
+    ]);
+    return;
+  }
+
+  applyInstallPlan(plan);
+  installNativeBundle();
+}
+
+await main();

package/scripts/tui-installer.js

@@ -0,0 +1,290 @@
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { detectAiCliStatus, resolveInstallHomeDir } from '../lib/aigentry.js';
+
+const require = createRequire(import.meta.url);
+
+function waitForKeypress(screen, keys = ['enter', 'space', 'escape']) {
+  return new Promise((resolve) => {
+    const handler = (_, key) => {
+      if (!key || !keys.includes(key.name)) {
+        return;
+      }
+      screen.off('keypress', handler);
+      resolve();
+    };
+    screen.on('keypress', handler);
+  });
+}
+
+async function showInfoScreen(blessed, title, lines, footer) {
+  const screen = blessed.screen({
+    smartCSR: true,
+    title: 'aterm installer',
+    fullUnicode: true,
+  });
+
+  blessed.box({
+    parent: screen,
+    top: 'center',
+    left: 'center',
+    width: '78%',
+    height: Math.max(12, lines.length + 6),
+    border: { type: 'line' },
+    tags: true,
+    label: ` ${title} `,
+    style: {
+      border: { fg: 'cyan' },
+      fg: 'white',
+    },
+    content: `${lines.join('\n')}\n\n${footer}`,
+  });
+
+  screen.render();
+  await waitForKeypress(screen);
+  screen.destroy();
+}
+
+function buildWorkspaceChoices(context) {
+  const choices = [];
+  if (context.orchestratorAvailable) {
+    choices.push({
+      title: 'aigentry-orchestrator',
+      value: 'orchestrator',
+      description: context.orchestratorPath,
+    });
+  }
+
+  if (context.mode === 'local') {
+    choices.push({
+      title: 'current project',
+      value: 'project',
+      description: context.projectRoot,
+    });
+  }
+
+  choices.push({
+    title: 'home directory',
+    value: 'home',
+    description: resolveInstallHomeDir(),
+  });
+
+  return choices;
+}
+
+function buildConfigPatch(context, answers) {
+  const workspacePathMap = {
+    orchestrator: context.orchestratorPath,
+    project: context.projectRoot,
+    home: resolveInstallHomeDir(),
+  };
+
+  return {
+    shell: {
+      default: answers.defaultShell,
+    },
+    workspace: {
+      default: answers.defaultWorkspace,
+      path: workspacePathMap[answers.defaultWorkspace] ?? resolveInstallHomeDir(),
+    },
+    orchestrator: {
+      enabled: answers.defaultWorkspace === 'orchestrator',
+      path: context.orchestratorPath,
+    },
+    tailscale: {
+      connect_on_launch: answers.tailscaleConnect,
+    },
+    ai: {
+      detected_clis: context.cliStatus,
+    },
+  };
+}
+
+export async function runInstallerTui(context) {
+  const blessed = require('blessed');
+  const prompts = (await import('prompts')).default;
+
+  await showInfoScreen(
+    blessed,
+    ' aterm Installer ',
+    [
+      '{center}{bold}Aigentry Terminal Installer{/bold}{/center}',
+      '',
+      'This installer will prepare the requested aigentry config level(s),',
+      'write default settings, and stage the native aterm bundle.',
+      '',
+      `Detected install mode: ${context.mode}`,
+    ],
+    '{gray-fg}Press Enter to continue{/}',
+  );
+
+  const cliLines = [
+    '{bold}AI CLI detection{/bold}',
+    '',
+    `claude ${context.cliStatus.claude ? '✅' : '❌'}`,
+    `codex  ${context.cliStatus.codex ? '✅' : '❌'}`,
+    `gemini ${context.cliStatus.gemini ? '✅' : '❌'}`,
+  ];
+
+  await showInfoScreen(
+    blessed,
+    ' CLI Status ',
+    cliLines,
+    '{gray-fg}Press Enter to continue{/}',
+  );
+
+  const workspaceChoices = buildWorkspaceChoices(context);
+  const defaultResponses = {
+    installLevels: context.availableLevels.map(level => level.value),
+    defaultShell: 'zsh',
+    defaultWorkspace: workspaceChoices[0]?.value ?? 'home',
+    tailscaleConnect: false,
+  };
+
+  const responses = await prompts(
+    [
+      {
+        type: 'multiselect',
+        name: 'installLevels',
+        message: 'Install level selection',
+        choices: context.availableLevels,
+        initial: 0,
+        instructions: false,
+        min: 1,
+      },
+      {
+        type: 'select',
+        name: 'defaultShell',
+        message: 'Default shell',
+        choices: [
+          { title: 'zsh', value: 'zsh' },
+          { title: 'bash', value: 'bash' },
+          { title: 'fish', value: 'fish' },
+        ],
+        initial: 0,
+      },
+      {
+        type: 'select',
+        name: 'defaultWorkspace',
+        message: 'Default workspace / orchestrator target',
+        choices: workspaceChoices,
+        initial: 0,
+      },
+      {
+        type: 'toggle',
+        name: 'tailscaleConnect',
+        message: 'Enable Tailscale connect on launch?',
+        initial: false,
+        active: 'yes',
+        inactive: 'no',
+      },
+    ],
+    {
+      onCancel: () => true,
+    },
+  );
+
+  const mergedAnswers = {
+    ...defaultResponses,
+    ...responses,
+  };
+
+  return {
+    installLevels: mergedAnswers.installLevels,
+    configPatch: buildConfigPatch(context, mergedAnswers),
+    summary: mergedAnswers,
+  };
+}
+
+export function shouldRunInstallerTui() {
+  if (process.env.CI) {
+    return false;
+  }
+  if (process.env.npm_config_yes === 'true') {
+    return false;
+  }
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+export function buildInstallerContext(mode, projectRoot = null) {
+  const installHome = resolveInstallHomeDir();
+  const orchestratorPath = path.join(installHome, 'projects', 'aigentry-orchestrator');
+  const cliStatus = detectAiCliStatus(installHome);
+  const availableLevels = mode === 'global'
+    ? [
+        {
+          title: 'system',
+          value: 'system',
+          description: 'Create /etc/aigentry/config/aterm.json when writable',
+        },
+        {
+          title: 'user',
+          value: 'user',
+          description: `Create ${path.join(installHome, '.aigentry')}`,
+        },
+      ]
+    : [
+        {
+          title: 'project',
+          value: 'project',
+          description: `Create ${path.join(projectRoot ?? process.cwd(), '.aigentry')}`,
+        },
+      ];
+
+  return {
+    mode,
+    projectRoot,
+    cliStatus,
+    orchestratorPath,
+    orchestratorAvailable: require('node:fs').existsSync(orchestratorPath),
+    availableLevels,
+  };
+}
+
+export async function showProgressScreen(runSteps) {
+  const blessed = require('blessed');
+  const screen = blessed.screen({
+    smartCSR: true,
+    title: 'aterm installer',
+    fullUnicode: true,
+  });
+
+  const box = blessed.log({
+    parent: screen,
+    top: 'center',
+    left: 'center',
+    width: '84%',
+    height: '70%',
+    border: { type: 'line' },
+    tags: true,
+    label: ' Installation Progress ',
+    style: {
+      border: { fg: 'green' },
+      fg: 'white',
+    },
+    scrollable: true,
+    alwaysScroll: true,
+    scrollbar: { ch: ' ', inverse: true },
+  });
+
+  const report = (line) => {
+    box.add(line);
+    screen.render();
+  };
+
+  screen.render();
+  await runSteps(report);
+  await new Promise(resolve => setTimeout(resolve, 250));
+  screen.destroy();
+}
+
+export async function showDoneScreen(summaryLines) {
+  const blessed = require('blessed');
+  await showInfoScreen(
+    blessed,
+    ' Install Complete ',
+    summaryLines,
+    '{green-fg}Run: aterm{/}',
+  );
+}

package/install.js

@@ -1,82 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createRequire } from 'node:module';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const require = createRequire(import.meta.url);
-const packageJson = JSON.parse(
-  fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8'),
-);
-
-const PLATFORM_PACKAGES = {
-  darwin: {
-    arm64: '@dmsdc-ai/aterm-darwin-arm64',
-  },
-};
-
-function resolvePlatformPackage() {
-  return PLATFORM_PACKAGES[os.platform()]?.[os.arch()] ?? null;
-}
-
-function bootstrapEcosystem() {
-  const homeDir = os.homedir();
-  const directories = [
-    path.join(homeDir, '.aigentry', 'inbox'),
-    path.join(homeDir, '.aigentry', 'config'),
-    path.join(homeDir, '.aigentry', 'brain', 'local'),
-    path.join(homeDir, '.aigentry', 'brain', 'profiles'),
-    path.join(homeDir, '.aigentry', 'brain', 'search'),
-    path.join(homeDir, '.telepty', 'shared'),
-    path.join(homeDir, 'Library', 'Application Support', 'aterm'),
-  ];
-
-  for (const directory of directories) {
-    fs.mkdirSync(directory, { recursive: true });
-  }
-
-  const configPath = path.join(homeDir, '.aigentry', 'config', 'aterm.json');
-  if (!fs.existsSync(configPath)) {
-    const defaultConfig = {
-      version: packageJson.version,
-      installed_at: new Date().toISOString(),
-      platform: `${os.platform()}-${os.arch()}`,
-    };
-    fs.writeFileSync(`${configPath}`, `${JSON.stringify(defaultConfig, null, 2)}\n`);
-  }
-}
-
-bootstrapEcosystem();
-
-const platformPackage = resolvePlatformPackage();
-if (!platformPackage) {
-  console.warn(`[aterm] no native package for ${os.platform()} ${os.arch()}; install skipped`);
-  process.exit(0);
-}
-
-let platformPackageJsonPath;
-try {
-  platformPackageJsonPath = require.resolve(`${platformPackage}/package.json`);
-} catch (error) {
-  console.warn(`[aterm] optional native package not installed: ${platformPackage}`);
-  console.warn('[aterm] reinstall after the platform package is available');
-  process.exit(0);
-}
-
-const platformRoot = path.dirname(platformPackageJsonPath);
-const sourceApp = path.join(platformRoot, 'dist', 'aterm.app');
-const targetApp = path.join(__dirname, 'dist', 'aterm.app');
-
-if (!fs.existsSync(sourceApp)) {
-  console.error(`[aterm] native app bundle missing from ${platformPackage}: ${sourceApp}`);
-  process.exit(1);
-}
-
-fs.rmSync(path.dirname(targetApp), { recursive: true, force: true });
-fs.mkdirSync(path.dirname(targetApp), { recursive: true });
-fs.cpSync(sourceApp, targetApp, { recursive: true });
-
-console.log(`[aterm] installed native bundle from ${platformPackage}`);