notioncode 0.1.0

package/README.md

@@ -0,0 +1,38 @@
+# @nocodenotioncode
+
+Run the Notion Code local companion without opening the Tauri desktop shell.
+
+## Intended usage
+
+```bash
+npx @nocodenotioncode start
+```
+
+Options:
+
+```bash
+npx @nocodenotioncode install
+npx @nocodenotioncode doctor
+npx @nocodenotioncode start --with-local-ui
+```
+
+## What it starts
+
+- localhost bridge on `127.0.0.1:3456`
+- optional local UI on `127.0.0.1:1420`
+- browser handoff to `https://www.notioncode.live`
+
+## Bridge binaries
+
+The package prefers a prebuilt bridge binary and falls back to a locally built binary when running from source.
+
+Environment variables:
+
+- `NOCODE_BRIDGE_BIN`
+- `NOCODE_COMPANION_ASSET_BASE_URL`
+- `NOCODE_CLOUD_URL`
+- `NOCODE_NO_OPEN=1`
+
+## Current limitation
+
+This package is implemented inside the source tree and still expects local runtime assets from this repository. It is publication-ready in interface and metadata, but the final standalone distribution still needs packaged runtime assets for the agent sidecar.

package/bin/nocode-local.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+import process from 'node:process';
+
+import { ensureBridgeBinary, buildLocalBridgeAsset } from '../lib/install.js';
+import { startLocalCompanion } from '../lib/start.js';
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args.find((arg) => !arg.startsWith('-')) || 'start';
+  const withLocalUi = args.includes('--no-local-ui') ? false : true;
+  if (args.includes('--no-open')) {
+    process.env.NOCODE_NO_OPEN = '1';
+  }
+
+  if (command === 'doctor') {
+    const checks = [
+      ['node', process.version],
+      ['platform', `${process.platform}/${process.arch}`],
+    ];
+    for (const [label, detail] of checks) {
+      console.log(`[OK] ${label}: ${detail}`);
+    }
+    return;
+  }
+
+  if (command === 'install') {
+    const bridgePath = await ensureBridgeBinary();
+    console.log(`[notioncode] Bridge ready at ${bridgePath}`);
+    return;
+  }
+
+  if (command === 'package-bridge') {
+    const asset = buildLocalBridgeAsset();
+    console.log(`[notioncode] Packaged bridge asset at ${asset}`);
+    return;
+  }
+
+  if (command === 'start') {
+    await startLocalCompanion({ withLocalUi });
+    return;
+  }
+
+  console.error(`Unknown command: ${command}`);
+  process.exit(1);
+}
+
+main().catch((error) => {
+  console.error('[notioncode] Fatal error:', error);
+  process.exit(1);
+});

package/lib/install.js

@@ -0,0 +1,119 @@
+import { chmodSync, copyFileSync, createWriteStream, existsSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { pipeline } from 'node:stream/promises';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+import { commandForPlatform, defaultCacheDir, resolvePlatformTarget } from './platform.js';
+
+const DEFAULT_VERSION = '0.1.0';
+const DEFAULT_ASSET_BASE =
+  process.env.NOCODE_COMPANION_ASSET_BASE_URL ||
+  'https://github.com/tadkt/nocode/releases/download';
+
+function packageRootDir() {
+  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+}
+
+function repoRootDir() {
+  if (process.env.NOCODE_RUNTIME_ROOT) {
+    return process.env.NOCODE_RUNTIME_ROOT;
+  }
+  return path.resolve(packageRootDir(), '..', '..');
+}
+
+function localBinaryName() {
+  return process.platform === 'win32' ? 'nocode-bridge.exe' : 'nocode-bridge';
+}
+
+function canUseCargo() {
+  const result = spawnSync(commandForPlatform('cargo'), ['--version'], {
+    stdio: 'ignore',
+  });
+  return result.status === 0;
+}
+
+export function resolveInstallRoot() {
+  return process.env.NOCODE_COMPANION_HOME || defaultCacheDir();
+}
+
+export function resolveInstalledBridgePath(version = DEFAULT_VERSION) {
+  return path.join(resolveInstallRoot(), 'bridge', version, localBinaryName());
+}
+
+export function resolveLocalSourceBridgePath() {
+  const repoRoot = repoRootDir();
+  return path.join(repoRoot, 'src-tauri', 'target', 'release', process.platform === 'win32' ? 'bridge_dev.exe' : 'bridge_dev');
+}
+
+export async function ensureBridgeBinary(version = DEFAULT_VERSION) {
+  const envPath = process.env.NOCODE_BRIDGE_BIN;
+  if (envPath && existsSync(envPath)) {
+    return envPath;
+  }
+
+  const installed = resolveInstalledBridgePath(version);
+  if (existsSync(installed)) {
+    return installed;
+  }
+
+  const localBuilt = resolveLocalSourceBridgePath();
+  if (existsSync(localBuilt)) {
+    return localBuilt;
+  }
+
+  const repoRoot = repoRootDir();
+  if (existsSync(path.join(repoRoot, 'src-tauri', 'Cargo.toml')) && canUseCargo()) {
+    return buildLocalBridgeAsset(version);
+  }
+
+  await downloadBridgeBinary(version, installed);
+  return installed;
+}
+
+export async function downloadBridgeBinary(version = DEFAULT_VERSION, destination = resolveInstalledBridgePath(version)) {
+  mkdirSync(path.dirname(destination), { recursive: true });
+  const target = resolvePlatformTarget();
+  const assetName = `nocode-bridge-${target}${process.platform === 'win32' ? '.exe' : ''}`;
+  const url = `${DEFAULT_ASSET_BASE}/notioncode-v${version}/${assetName}`;
+
+  const response = await fetch(url);
+  if (!response.ok || !response.body) {
+    throw new Error(`Failed to download bridge binary from ${url} (${response.status})`);
+  }
+
+  await pipeline(response.body, createWriteStream(destination));
+  if (process.platform !== 'win32') {
+    chmodSync(destination, 0o755);
+  }
+  return destination;
+}
+
+export function buildLocalBridgeAsset(version = DEFAULT_VERSION) {
+  const repoRoot = repoRootDir();
+  const cargo = commandForPlatform('cargo');
+  const build = spawnSync(
+    cargo,
+    ['build', '--manifest-path', 'src-tauri/Cargo.toml', '--bin', 'bridge_dev', '--release'],
+    { cwd: repoRoot, stdio: 'inherit' }
+  );
+  if (build.status !== 0) {
+    throw new Error(`cargo build failed with code ${build.status ?? 1}`);
+  }
+
+  const source = resolveLocalSourceBridgePath();
+  if (!existsSync(source)) {
+    throw new Error(`Expected built bridge binary at ${source}`);
+  }
+
+  const artifactsDir = path.join(repoRoot, 'artifacts', 'local-companion', version);
+  mkdirSync(artifactsDir, { recursive: true });
+  const target = resolvePlatformTarget();
+  const dest = path.join(artifactsDir, `nocode-bridge-${target}${process.platform === 'win32' ? '.exe' : ''}`);
+  copyFileSync(source, dest);
+  if (process.platform !== 'win32') {
+    chmodSync(dest, 0o755);
+  }
+  return dest;
+}

package/lib/platform.js

@@ -0,0 +1,26 @@
+import os from 'node:os';
+
+export function resolvePlatformTarget() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  if (platform === 'darwin' && arch === 'arm64') return 'darwin-arm64';
+  if (platform === 'darwin' && arch === 'x64') return 'darwin-x64';
+  if (platform === 'linux' && arch === 'x64') return 'linux-x64';
+  if (platform === 'win32' && arch === 'x64') return 'windows-x64';
+
+  throw new Error(`Unsupported platform for Notion Code local companion: ${platform}/${arch}`);
+}
+
+export function commandForPlatform(base) {
+  return process.platform === 'win32' ? `${base}.cmd` : base;
+}
+
+export function defaultCacheDir() {
+  const home = os.homedir();
+  if (process.platform === 'darwin') return `${home}/Library/Application Support/notioncode`;
+  if (process.platform === 'win32') {
+    return `${process.env.APPDATA || `${home}\\AppData\\Roaming`}\\notioncode`;
+  }
+  return `${process.env.XDG_CONFIG_HOME || `${home}/.config`}/notioncode`;
+}

package/lib/start.js

@@ -0,0 +1,194 @@
+import path from 'node:path';
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { setTimeout as sleep } from 'node:timers/promises';
+
+import { commandForPlatform } from './platform.js';
+import { ensureBridgeBinary } from './install.js';
+
+const BRIDGE_HEALTH_URL = 'http://127.0.0.1:3456/healthz';
+const LOCAL_UI_URL = 'http://127.0.0.1:1420/';
+const CLOUD_URL = process.env.NOCODE_CLOUD_URL || 'https://www.notioncode.live';
+
+function packageRootDir() {
+  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+}
+
+function detectRuntimeRoot() {
+  if (process.env.NOCODE_RUNTIME_ROOT) {
+    return process.env.NOCODE_RUNTIME_ROOT;
+  }
+
+  const candidates = [
+    path.resolve(packageRootDir(), '..', '..'),
+    process.cwd(),
+    path.resolve(packageRootDir(), '..'),
+  ];
+
+  for (const candidate of candidates) {
+    if (existsSync(path.join(candidate, 'agent-runtime-server', 'package.json'))) {
+      return candidate;
+    }
+  }
+
+  return path.resolve(packageRootDir(), '..', '..');
+}
+
+function spawnLogged(cmd, args, options = {}) {
+  return spawn(cmd, args, {
+    cwd: options.cwd,
+    env: { ...process.env, ...(options.env || {}) },
+    stdio: 'inherit',
+    shell: false,
+  });
+}
+
+async function isReady(url) {
+  try {
+    const response = await fetch(url, { method: 'GET' });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+async function waitFor(url, timeoutMs, label) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError = null;
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(url, { method: 'GET' });
+      if (response.ok) return;
+      lastError = new Error(`${label} returned ${response.status}`);
+    } catch (error) {
+      lastError = error;
+    }
+    await sleep(300);
+  }
+  throw lastError || new Error(`${label} did not become ready.`);
+}
+
+function openBrowser(url) {
+  if (process.env.NOCODE_NO_OPEN === '1') return;
+  if (process.platform === 'darwin') {
+    spawn(commandForPlatform('open'), [url], { stdio: 'ignore', detached: true }).unref();
+    return;
+  }
+  if (process.platform === 'win32') {
+    spawn('cmd', ['/c', 'start', '', url], { stdio: 'ignore', detached: true }).unref();
+    return;
+  }
+  spawn(commandForPlatform('xdg-open'), [url], { stdio: 'ignore', detached: true }).unref();
+}
+
+function hasLocalUiRepo() {
+  const runtimeRoot = detectRuntimeRoot();
+  return existsSync(path.join(runtimeRoot, 'package.json')) && existsSync(path.join(runtimeRoot, 'node_modules', 'vite', 'bin', 'vite.js'));
+}
+
+function hasCargoBridgeSource(runtimeRoot) {
+  return existsSync(path.join(runtimeRoot, 'src-tauri', 'Cargo.toml'));
+}
+
+function canUseCargo() {
+  const result = spawnSync(commandForPlatform('cargo'), ['--version'], {
+    stdio: 'ignore',
+  });
+  return result.status === 0;
+}
+
+function ensureSidecarInstallIfRepoPresent() {
+  const runtimeRoot = detectRuntimeRoot();
+  if (!existsSync(path.join(runtimeRoot, 'agent-runtime-server', 'package.json'))) {
+    return;
+  }
+
+  const npmCmd = commandForPlatform('npm');
+  const result = spawnSync(npmCmd, ['--prefix', 'agent-runtime-server', 'install'], {
+    cwd: runtimeRoot,
+    stdio: 'inherit',
+  });
+  if (result.status !== 0) {
+    throw new Error(`Failed to install agent-runtime-server dependencies (${result.status ?? 1})`);
+  }
+}
+
+export async function startLocalCompanion(options = {}) {
+  const runtimeRoot = detectRuntimeRoot();
+  const requestedLocalUi = options.withLocalUi !== false;
+  const shouldStartLocalUi = requestedLocalUi && hasLocalUiRepo();
+  const useCargoBridge = hasCargoBridgeSource(runtimeRoot) && canUseCargo();
+  const bridgeExecutable = useCargoBridge ? null : await ensureBridgeBinary(options.version);
+
+  ensureSidecarInstallIfRepoPresent();
+
+  let vite = null;
+  if (shouldStartLocalUi) {
+    if (await isReady(LOCAL_UI_URL)) {
+      console.log('[notioncode] Reusing existing local UI on http://127.0.0.1:1420 .');
+    } else {
+      console.log('[notioncode] Starting local UI on http://127.0.0.1:1420 ...');
+      vite = spawnLogged(commandForPlatform('node'), ['node_modules/vite/bin/vite.js', '--host', '127.0.0.1'], {
+        cwd: runtimeRoot,
+        env: {
+          VITE_SINGLE_USER_MODE: 'true',
+        },
+      });
+    }
+  }
+
+  let bridge = null;
+  if (await isReady(BRIDGE_HEALTH_URL)) {
+    console.log('[notioncode] Reusing existing bridge on http://127.0.0.1:3456 .');
+  } else {
+    console.log('[notioncode] Starting local bridge on http://127.0.0.1:3456 ...');
+    if (useCargoBridge) {
+      bridge = spawnLogged(
+        commandForPlatform('cargo'),
+        ['run', '--manifest-path', 'src-tauri/Cargo.toml', '--bin', 'bridge_dev'],
+        { cwd: runtimeRoot }
+      );
+    } else {
+      bridge = spawnLogged(bridgeExecutable, [], {
+        cwd: runtimeRoot,
+        env: {
+          NOTION_BRIDGE_URL: 'http://127.0.0.1:3456',
+        },
+      });
+    }
+  }
+
+  const shutdown = (code = 0) => {
+    vite?.kill('SIGTERM');
+    bridge?.kill('SIGTERM');
+    setTimeout(() => process.exit(code), 250);
+  };
+
+  process.on('SIGINT', () => shutdown(0));
+  process.on('SIGTERM', () => shutdown(0));
+
+  vite?.on('exit', (code) => {
+    console.error(`[notioncode] Local UI exited with code ${code ?? 1}.`);
+    shutdown(code ?? 1);
+  });
+  bridge?.on('exit', (code) => {
+    console.error(`[notioncode] Bridge exited with code ${code ?? 1}.`);
+    shutdown(code ?? 1);
+  });
+
+  const bridgeTimeoutMs = useCargoBridge ? 180_000 : 15_000;
+  await waitFor(BRIDGE_HEALTH_URL, bridgeTimeoutMs, 'Bridge');
+  if (shouldStartLocalUi) {
+    await waitFor(LOCAL_UI_URL, 15_000, 'Local UI');
+  }
+
+  console.log('[notioncode] Ready.');
+  console.log(`[notioncode] Cloud UI: ${CLOUD_URL}`);
+  if (shouldStartLocalUi) {
+    console.log(`[notioncode] Local UI: ${LOCAL_UI_URL}`);
+  }
+  const entryUrl = shouldStartLocalUi ? LOCAL_UI_URL : CLOUD_URL;
+  console.log(`[notioncode] Opening: ${entryUrl}`);
+  openBrowser(entryUrl);
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "notioncode",
+  "version": "0.1.0",
+  "description": "Run the Notion Code local companion bridge and open the cloud UI.",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "notioncode": "bin/nocode-local.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20.19.0"
+  }
+}