@tokentestai/ais 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 labber
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.en.md

@@ -0,0 +1,238 @@
+<p align="right">
+  <a href="./README.md">简体中文</a> | English | <a href="./README.ko.md">한국어</a> | <a href="./README.ja.md">日本語</a> | <a href="./README.fr.md">Français</a>
+</p>
+
+# AIS
+
+> A local command-line tool you can install with a single `npm` command to help protect passwords, keys, and connection strings when using AI agents.
+
+`AIS` is built around a simple goal:
+
+- You can still hand secrets to AI so it can do real work
+- The AI should see as little real secret data as possible
+- Real secrets should be restored only on your own machine when they are actually needed
+- The workflow should still succeed normally
+
+<p align="center">
+  <img src="./docs/images/readme-flow-en.jpg" alt="AIS workflow: a real password is replaced locally, the cloud AI only sees a placeholder token, and the real password is restored locally only when needed" width="100%" />
+</p>
+
+## Install In One Line
+
+```bash
+npm install -g @tokentestai/ais
+```
+
+After installation, the command name is `ais`.
+
+Current status:
+
+- Native support for `macOS` and `Linux`
+- `Windows` support is still being expanded
+- Native support for `Claude Code`, `Codex`, and `OpenClaw`
+
+## What Problem Does It Solve?
+
+More and more people now give website passwords, server passwords, database URLs, API keys, and other sensitive values to AI agents so the agents can log in, deploy, edit config files, fill forms, and run commands.
+
+That is convenient, and it is clearly becoming part of everyday workflows.
+
+But the problem is also obvious:
+
+- If you give the AI the **real password in plain text**, that password may enter the AI-visible path
+- Once the real password leaves your machine, it becomes much harder to control what logs, support systems, storage layers, or downstream services may touch it
+- If you use official APIs or third-party API providers, those providers may still be in a technical position to observe request contents
+
+`AIS` is trying to solve one thing:
+
+**Do not let the real password leave your machine unless it absolutely has to.**
+
+## The Easiest Way To Understand It
+
+Suppose you ask an AI agent to log into a website for you, and the real password is:
+
+```text
+qwert123
+```
+
+`AIS` first replaces it locally with a placeholder token such as:
+
+```text
+__SECRET_01__
+```
+
+At that point:
+
+- the AI sees `__SECRET_01__`
+- the AI provider sees `__SECRET_01__`
+- the real `qwert123` is not directly sent out
+
+Later, when the AI actually needs to perform the login on your machine, `AIS` locally restores:
+
+```text
+__SECRET_01__ -> qwert123
+```
+
+So the website still receives the correct real password `qwert123`, and the task does not fail just because a protection layer was added.
+
+## How It Works
+
+The full process can be explained in 5 steps:
+
+1. You give the AI a real password, key, or connection string so it can complete a task.
+2. `AIS` detects that sensitive value locally and replaces it with a placeholder token.
+3. When data goes to the cloud, the AI sees the placeholder token instead of the real value.
+4. When the AI is actually executing a local command, filling a form, or writing config on your machine, `AIS` restores the real value locally.
+5. The task still completes, but the real secret tries not to leave your machine.
+
+In plain language:
+
+- hide it locally before sending
+- restore it locally only when actually needed
+
+## Why We Built It
+
+We are heavy users of `Claude Code`, `Codex`, and `OpenClaw` ourselves.
+
+We believe people will continue giving AI agents more permissions, not fewer.
+
+The question is not whether AI should help with real work.
+
+The real question is:
+
+**Can we give AI more authority without letting real passwords travel around in plain text?**
+
+That is the reason `AIS` exists:
+
+- local-first
+- open source
+- minimal friction
+- focused on one practical layer of risk reduction
+
+## What You Can Use It For
+
+- Let an AI log into websites without sending the real website password to the cloud in plain text
+- Let an AI operate servers without exposing the raw server password to outside model pipelines
+- Let an AI write config files, call APIs, and run scripts without directly exposing keys and connection strings
+- Keep the convenience of automation while reducing unnecessary secret exposure
+
+## Quick Start
+
+Create local config first:
+
+```bash
+ais config
+```
+
+If you want to manually save a secret first:
+
+```bash
+ais add github-token
+ais add github-token ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+```
+
+Wrap `Claude Code`:
+
+```bash
+ais claude
+```
+
+Wrap `Codex`:
+
+```bash
+ais -- codex --sandbox danger-full-access
+```
+
+Wrap `OpenClaw`:
+
+```bash
+ais -- openclaw <the arguments you would normally run>
+```
+
+## Terminal UI
+
+`AIS` also includes a terminal UI so you can:
+
+- review which values were successfully protected
+- mark some values as “do not protect”
+- inspect and adjust local behavior
+
+Open it with:
+
+```bash
+ais ais
+```
+
+For example:
+
+```bash
+ais ais exclude <id>
+ais ais exclude-type PASSWORD
+```
+
+## Why “Local-Only” Matters
+
+The point is not to make secrets look prettier.
+
+The point is this:
+
+**real passwords should stay on your machine whenever possible.**
+
+If the real password still needs to travel out, you still lose direct control over what may happen later.
+
+`AIS` is trying to keep the most important steps local:
+
+- local detection
+- local replacement
+- local restoration
+- local execution
+
+## Current Limits
+
+We do not present this as a magical security tool.
+
+It is useful, but it does not solve everything.
+
+Important limits:
+
+- If your local machine is already compromised, this will not save you
+- It is not a permission system and does not replace least privilege, auditing, or isolation
+- If a placeholder token is split, transformed, or rewritten, restoration may fail in some cases
+- If a tool chain completely bypasses the locally visible layers, protection may be limited
+
+So the accurate claim is:
+
+`AIS` helps **reduce the chance that real secrets leave your machine**, but it does not mean “everything is safe forever.”
+
+## Who Is It For?
+
+- People who already use AI agents for real operational work
+- People who want to give AI more authority but do not want plain-text passwords floating around
+- People using official APIs or third-party API providers who want one more local layer of control
+- People who want better automation without a large usability penalty
+
+## Local Validation
+
+If you want to validate the current version locally:
+
+```bash
+npm install
+npm run lint
+npm run build
+npm run test
+npm run typecheck
+```
+
+## Open Source
+
+This is a local-first open source tool.
+
+It is not trying to replace every part of your security model.
+
+It is trying to fix one of the most common and practical problems in modern AI workflows:
+
+**if you must give a password to AI, do not send the real password out in plain text first.**
+
+## License
+
+MIT

package/README.fr.md

@@ -0,0 +1,238 @@
+<p align="right">
+  <a href="./README.md">简体中文</a> | <a href="./README.en.md">English</a> | <a href="./README.ko.md">한국어</a> | <a href="./README.ja.md">日本語</a> | Français
+</p>
+
+# AIS
+
+> Un outil en ligne de commande que vous pouvez installer avec une seule commande `npm`, et qui aide à protéger mots de passe, clés et chaînes de connexion pour les agents IA, tout en fonctionnant **entièrement en local**.
+
+L’objectif de `AIS` est simple :
+
+- vous pouvez continuer à confier un vrai travail à une IA
+- l’IA doit voir le moins possible les vrais secrets
+- les vrais secrets ne sont restaurés que sur votre propre machine, au moment exact où ils sont nécessaires
+- le workflow doit quand même réussir normalement
+
+<p align="center">
+  <img src="./docs/images/readme-flow-fr.jpg" alt="Fonctionnement d’AIS : le vrai mot de passe est d’abord remplacé localement par un jeton, l’IA dans le cloud ne voit que ce jeton, puis le vrai mot de passe est restauré localement uniquement au moment nécessaire" width="100%" />
+</p>
+
+## Installation En Une Ligne
+
+```bash
+npm install -g @tokentestai/ais
+```
+
+Après installation, la commande à utiliser est `ais`.
+
+État actuel :
+
+- prise en charge native de `macOS` et `Linux`
+- prise en charge de `Windows` encore en cours
+- prise en charge native de `Claude Code`, `Codex` et `OpenClaw`
+
+## Quel Problème Est Résolu ?
+
+De plus en plus de personnes donnent à des agents IA des mots de passe de sites, des mots de passe serveur, des chaînes de connexion de base de données, des clés API et d’autres informations sensibles pour que l’agent puisse se connecter, déployer, remplir des formulaires ou lancer des commandes.
+
+C’est pratique, et cela devient clairement une tendance de fond.
+
+Mais le problème est évident :
+
+- si vous donnez à l’IA le **vrai mot de passe en clair**, cette donnée peut entrer dans un chemin visible par l’IA
+- dès que le vrai mot de passe quitte votre machine, il devient beaucoup plus difficile de contrôler quels journaux, systèmes de support, couches de stockage ou services en aval peuvent y avoir accès
+- que vous utilisiez des API officielles ou des fournisseurs d’API tiers, ces acteurs peuvent techniquement se trouver dans une position leur permettant d’observer le contenu des requêtes
+
+`AIS` essaie de résoudre une chose :
+
+**éviter que le vrai mot de passe quitte votre machine sans nécessité.**
+
+## La Façon La Plus Simple De Le Comprendre
+
+Supposons que vous demandiez à une IA de se connecter à un site pour vous, et que le vrai mot de passe soit :
+
+```text
+qwert123
+```
+
+`AIS` le remplace d’abord localement par un jeton de substitution comme :
+
+```text
+__SECRET_01__
+```
+
+À partir de là :
+
+- l’IA voit `__SECRET_01__`
+- le fournisseur de service IA voit aussi `__SECRET_01__`
+- le vrai `qwert123` n’est pas envoyé directement
+
+Ensuite, lorsque l’IA doit réellement exécuter l’action de connexion sur votre machine, `AIS` restaure localement :
+
+```text
+__SECRET_01__ -> qwert123
+```
+
+Ainsi, le site reçoit toujours le bon mot de passe réel `qwert123`, et la tâche ne rate pas simplement parce qu’une couche de protection a été ajoutée.
+
+## Comment Ça Marche
+
+Le processus complet peut se résumer en 5 étapes :
+
+1. Vous donnez à l’IA un vrai mot de passe, une clé ou une chaîne de connexion pour qu’elle accomplisse une tâche.
+2. `AIS` détecte localement cette donnée sensible et la remplace par un jeton.
+3. Lorsque les données partent vers le cloud, l’IA ne voit que le jeton, pas la vraie valeur.
+4. Quand l’IA exécute réellement une commande locale, remplit un formulaire ou écrit une configuration sur votre machine, `AIS` restaure localement la vraie valeur.
+5. La tâche se termine normalement, mais le vrai secret essaie de ne pas quitter votre machine.
+
+En version très simple :
+
+- on masque localement avant l’envoi
+- on restaure localement seulement au moment utile
+
+## Pourquoi Nous L’avons Créé
+
+Nous sommes nous-mêmes de gros utilisateurs de `Claude Code`, `Codex` et `OpenClaw`.
+
+Nous pensons que les utilisateurs vont continuer à donner plus de permissions aux agents IA, pas moins.
+
+La vraie question n’est pas de savoir si l’IA doit aider à faire le travail.
+
+La vraie question est :
+
+**peut-on confier davantage à l’IA sans laisser les vrais mots de passe circuler en clair ?**
+
+C’est exactement pour cela que `AIS` existe :
+
+- local-first
+- open source
+- friction minimale
+- focalisé sur une couche concrète de réduction du risque
+
+## Cas D’usage
+
+- laisser une IA se connecter à des sites sans envoyer le vrai mot de passe du site en clair vers le cloud
+- laisser une IA opérer des serveurs sans exposer le mot de passe serveur brut à des pipelines de modèles externes
+- laisser une IA écrire des configs, appeler des API et lancer des scripts sans exposer directement clés et chaînes de connexion
+- conserver le confort de l’automatisation tout en réduisant l’exposition inutile des secrets
+
+## Démarrage Rapide
+
+Créez d’abord la configuration locale :
+
+```bash
+ais config
+```
+
+Si vous voulez enregistrer un secret manuellement :
+
+```bash
+ais add github-token
+ais add github-token ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+```
+
+Lancer `Claude Code` avec protection :
+
+```bash
+ais claude
+```
+
+Lancer `Codex` avec protection :
+
+```bash
+ais -- codex --sandbox danger-full-access
+```
+
+Lancer `OpenClaw` avec protection :
+
+```bash
+ais -- openclaw <les arguments que vous utilisez normalement>
+```
+
+## Interface Terminal
+
+`AIS` inclut aussi une interface terminal qui permet de :
+
+- voir quelles valeurs ont bien été protégées
+- marquer certaines valeurs comme “ne pas protéger”
+- inspecter et ajuster le comportement local
+
+Ouvrir l’interface :
+
+```bash
+ais ais
+```
+
+Par exemple :
+
+```bash
+ais ais exclude <id>
+ais ais exclude-type PASSWORD
+```
+
+## Pourquoi Le “Tout En Local” Est Important
+
+Le point n’est pas d’afficher les secrets d’une manière plus élégante.
+
+Le vrai point est le suivant :
+
+**les vrais mots de passe doivent rester sur votre machine autant que possible.**
+
+Si le vrai mot de passe continue à sortir de votre machine, vous perdez le contrôle direct de ce qui peut arriver ensuite.
+
+`AIS` essaie donc de garder les étapes critiques en local :
+
+- détection locale
+- remplacement local
+- restauration locale
+- exécution locale
+
+## Limites Actuelles
+
+Nous ne présentons pas cet outil comme une solution magique.
+
+Il est utile, mais il ne résout pas tout.
+
+Quelques limites importantes :
+
+- si votre machine locale est déjà compromise, cet outil ne suffira pas
+- ce n’est pas un système de permissions, et il ne remplace pas le moindre privilège, l’audit ou l’isolation
+- si un jeton est découpé, transformé ou réécrit, la restauration peut échouer dans certains cas
+- si une chaîne d’outils contourne complètement les couches visibles localement, la protection peut être limitée
+
+La bonne formulation est donc :
+
+`AIS` aide à **réduire la probabilité que les vrais secrets quittent votre machine**, mais cela ne veut pas dire “tout est désormais parfaitement sûr”.
+
+## À Qui S’adresse-t-il ?
+
+- aux personnes qui utilisent déjà des agents IA pour des tâches réelles
+- aux personnes qui veulent donner plus d’autonomie à l’IA sans laisser circuler des mots de passe en clair
+- aux personnes qui utilisent des API officielles ou des fournisseurs d’API tiers et veulent ajouter une couche locale de contrôle
+- aux personnes qui veulent plus d’automatisation sans trop sacrifier l’ergonomie
+
+## Validation Locale
+
+Si vous voulez valider la version actuelle en local :
+
+```bash
+npm install
+npm run lint
+npm run build
+npm run test
+npm run typecheck
+```
+
+## Open Source
+
+Il s’agit d’un outil open source, pensé d’abord pour le local.
+
+Il ne cherche pas à remplacer toute votre stratégie de sécurité.
+
+Il cherche à corriger une faiblesse très courante et très concrète dans les workflows IA modernes :
+
+**si vous devez donner un mot de passe à une IA, ne commencez pas par envoyer le vrai mot de passe en clair.**
+
+## Licence
+
+MIT